[英]Print the longest path starting from root in a binary tree
In this tree:在这棵树中:
a
/ \
b d
/ / \
c e f
/
g
The longest path starting from the root would be adfg
从根开始的最长路径是
adfg
Here is my attempt:这是我的尝试:
class Node:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def print_path(root):
if not root:
return []
if root.left is None:
return [root.val].append(print_path(root.right))
elif root.right is None:
return [root.val].append(print_path(root.left))
elif (root.right is None) and (root.left is None):
return [root.val]
else:
return argmax([root.val].append(print_path(root.left)), [root.val].append(print_path(root.right)))
def argmax(lst1, lst2):
return lst1 if len(lst1) > len(lst2) else lst2
if __name__ == '__main__':
root_node = Node('a')
root_node.left = Node('b')
root_node.right = Node('c')
root_node.right.right = Node('f')
print print_path(root_node)
The tree in the main()
function is not the example I have shown. main()
函数中的树不是我展示的例子。 For this tree the expected results would be acf
.对于这棵树,预期结果将是
acf
。 This tree is shown below:这棵树如下图所示:
a
/ \
b c
\
f
Right now, I get现在,我得到
TypeError: object of type 'NoneType' has no len()
I'm not sure how None
is showing up there since I have base cases.我不确定
None
是如何出现在那里的,因为我有基本案例。
Thanks!谢谢!
Here's a working implementation:这是一个有效的实现:
class Node:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def print_path(root):
rightpath = []
leftpath = []
path = []
if root is None:
return []
if (root.right is None) and (root.left is None):
return [root.val]
elif root.right is not None:
rightpath = [root.val] + print_path(root.right)
elif root.left is not None:
leftpath = [root.val] + print_path(root.left)
return argmax(rightpath, leftpath)
def argmax(lst1, lst2):
return lst1 if len(lst1) > len(lst2) else lst2
root_node = Node('a')
root_node.left = Node('b')
root_node.right = Node('c')
root_node.right.right = Node('f')
print print_path(root_node)
Couple of issues with your code:您的代码有几个问题:
1) checking root.left is None
before (root.right is None) and (root.left is None)
is incorrect - you'll never reach (root.right is None) and (root.left is None)
1) 之前检查
root.left is None
(root.right is None) and (root.left is None)
是不正确的 - 你永远不会到达(root.right is None) and (root.left is None)
2) instead of returning immediately, you want to use recursion and compare both branches and then return the branch with the longest path so far 2)而不是立即返回,您想使用递归并比较两个分支,然后返回迄今为止最长路径的分支
3) append
appends in place, so you need to store it in a variable 3)
append
appends in place,所以你需要把它存储在一个变量中
Edit: Cleaner implementation (see comments)编辑:更清洁的实现(见评论)
class Node:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def print_path(root):
rightpath = []
leftpath = []
if root is None:
return []
rightpath = [root.val] + print_path(root.right)
leftpath = [root.val] + print_path(root.left)
return argmax(rightpath, leftpath)
def argmax(lst1, lst2):
return lst1 if len(lst1) > len(lst2) else lst2
root_node = Node('a')
root_node.left = Node('b')
root_node.right = Node('c')
root_node.right.right = Node('f')
print print_path(root_node)
You can simplify your logic significantly by allowing one more level of recursion and letting the main logic handle what were (confusing) special cases before:您可以通过允许更多级别的递归并让主逻辑处理之前(令人困惑的)特殊情况来显着简化您的逻辑:
def print_path(root):
if root is None:
return []
return [root.val] + argmax(print_path(root.right), print_path(root.left))
The code should be edited as:代码应编辑为:
if (root.right is None) and (root.left is None):
return [root.val]
if root.right is not None:
rightpath = [root.val] + print_path(root.right)
if root.left is not None:
leftpath = [root.val] + print_path(root.left)
return argmax(rightpath, leftpath)
or the recursive function will always pass print_path(root.left) if the right.root is not None.或者递归函数将始终通过 print_path(root.left) 如果 right.root 不是 None 。
My solution我的解决方案
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
*Longest Path from root to leaf Node
* */
public class LongestPath {
public static void main(String[] args) {
BinaryTree bt = new BinaryTree();
Node root =bt.constructTree(bt);
List path = printPath(root);
Iterator itr = path.iterator();
while (itr.hasNext()){
System.out.print(itr.next() +" ");
}
}
public static List<Integer> printPath(Node root){
if(root ==null){
return null;
}
List<Integer> path = new ArrayList<>();
path.add(root.data);
List result = getMaxList(printPath(root.left), printPath(root.right));
if(result!=null) {
path.addAll(result);
}
return path;
}
public static List<Integer> getMaxList(List<Integer> list1, List<Integer> list2){
if(list1==null && list2==null){
return null;
}
if(list1==null){
return list2;
}
if(list2 == null){
return list1;
}
if(list1.size()> list2.size()){
return list1;
}else {
return list2;
}
}
}
Binary Tree二叉树
class Node
{
int data;
Node left, right;
Node(int item)
{
data = item;
left = right = null;
}
}
class BinaryTree
{
Node root;
/* Get width of a given level */
int getWidth(Node node, int level)
{
if (node == null)
return 0;
if (level == 1)
return 1;
else if (level > 1)
return getWidth(node.left, level - 1)
+ getWidth(node.right, level - 1);
return 0;
}
/* UTILITY FUNCTIONS */
/* Compute the "height" of a tree -- the number of
nodes along the longest path from the root node
down to the farthest leaf node.*/
int height(Node node)
{
if (node == null)
return 0;
else
{
/* compute the height of each subtree */
int lHeight = height(node.left);
int rHeight = height(node.right);
/* use the larger one */
return (lHeight > rHeight) ? (lHeight + 1) : (rHeight + 1);
}
}
/* Driver program to test above functions */
public Node constructTree( BinaryTree tree) {
/*
Constructed binary tree is:
1
/ \
2 3
/ \ \
4 5 8
/ \
6 7
*/
tree.root = new Node(1);
tree.root.left = new Node(2);
tree.root.right = new Node(3);
tree.root.left.left = new Node(4);
tree.root.left.right = new Node(5);
tree.root.right.right = new Node(8);
tree.root.right.right.left = new Node(6);
tree.root.right.right.right = new Node(7);
return tree.root;
}
}
OUTPUT 1 3 8 7输出1 3 8 7
Below is a C++ implementation.下面是一个 C++ 实现。
void longest_root_to_leaf_path(Node *root, std::vector<int> current_path,
std::vector<int> &longest_path) {
if (!root)
return;
current_path.push_back(root->data);
if (root->left == nullptr && root->right == nullptr) {
if (current_path.size() > longest_path.size())
longest_path = current_path;
return;
}
longest_root_to_leaf_path(root->left, current_path, longest_path);
longest_root_to_leaf_path(root->right, current_path, longest_path);
current_path.pop_back();
}
the above program was wrong in another case上述程序在另一种情况下是错误的
elif root.left is not None:
leftpath = [root.val] + print_path(root.left)
elif root.right is not None:
rightpath = [root.val] + print_path(root.right)
if you give like this the output would become [a,b] only which is not expected output如果你这样给出输出将变成 [a,b] 只是这不是预期的输出
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.