题目:
Given a binary tree, return all root-to-leaf paths.
Note: A leaf is a node with no children.
Example:
Input: 1 / \ 2 3 \ 5 Output: ["1->2->5", "1->3"] Explanation: All root-to-leaf paths are: 1->2->5, 1->3
打印binary tree的所有根到叶子的路径,感觉和之前做的path sum 2差不多,也是用到了一点回溯的思想。helper function里先把当前节点加入temp,然后check如果root是叶子的话就把当前路径加到result里,如果不是叶子的话就要左右两边分别继续递归,递归完了要记得remove掉。
Runtime: 1 ms, faster than 99.98% of Java online submissions for Binary Tree Paths.
Memory Usage: 39.5 MB, less than 7.90% of Java online submissions for Binary Tree Paths.
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<String> binaryTreePaths(TreeNode root) {
List<String> result = new ArrayList<>();
if (root == null) {
return result;
}
helper(root, new ArrayList<>(), result);
return result;
}
public void helper(TreeNode root, List<Integer> temp, List<String> result) {
temp.add(root.val);
if (root.left == null && root.right == null) {
StringBuilder sb = new StringBuilder();
for (int i : temp) {
sb.append(i);
sb.append("->");
}
result.add(sb.substring(0, sb.length() - 2).toString());
return;
}
if (root.left != null) {
helper(root.left, temp, result);
temp.remove(temp.size() - 1);
}
if (root.right != null) {
helper(root.right, temp, result);
temp.remove(temp.size() - 1);
}
}
}
看了下257. Binary Tree Paths · leetcode发现人家并不用回溯remove?我也不是很懂了,暂时不想研究了。
2023.1.13
上次这题做到一半跑了,今天接着上次wrong answer的代码就自己给改出来了。这里我采用的方法是用一个list来记录所有treenode,每次遇到一个就加进去一个,最后在这个方向递归完了以后需要把它们remove掉,不然就会带到后面的递归中。看了下大家的解法,很多都直接采用string作为参数,我猜因为string是immutable的,而list在被传入参数的时候还在被修改,所以递归回去以后新的节点都还在list里,因此需要删掉(真的是猜的,现在不想动脑了,以后再考证)。
具体的递归有两种写法,一种是判断root == null的情况,这样后面就不用单独判断左右子节点是否存在;另一种就是反过来。代码都贴了上来。
哦对,这个递归的本质其实也就是preorder traversal了。
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<String> binaryTreePaths(TreeNode root) {
List<String> result = new ArrayList<>();
helper(root, new ArrayList<>(), result);
return result;
}
private void helper(TreeNode root, List<TreeNode> temp, List<String> result) {
// option 1 part 1
if (root == null) {
return;
}
System.out.println(root.val);
if (root.left == null && root.right == null) {
temp.add(root);
result.add(buildString(temp));
temp.remove(root);
}
// option 1 part 2
temp.add(root);
helper(root.left, temp, result);
helper(root.right, temp,result);
temp.remove(root);
// option 2
// if (root.left != null) {
// temp.add(root);
// helper(root.left, temp, result);
// temp.remove(root);
// }
// if (root.right != null) {
// temp.add(root);
// helper(root.right, temp, result);
// temp.remove(root);
// }
}
private String buildString(List<TreeNode> list) {
StringBuilder sb = new StringBuilder();
for (TreeNode node : list) {
sb.append(node.val);
sb.append("->");
}
return sb.substring(0, sb.length() - 2).toString();
}
}
用string做的代码就很简单了。
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<String> binaryTreePaths(TreeNode root) {
List<String> result = new ArrayList<>();
helper(root, "", result);
return result;
}
private void helper(TreeNode root, String str, List<String> result) {
if (root == null) {
return;
}
if (root.left == null && root.right == null) {
result.add(str + root.val);
}
helper(root.left, str + root.val + "->", result);
helper(root.right, str + root.val + "->", result);
}
}
然后是BFS/DFS迭代,跟112一样,也是两个几乎是一样的,除了用的数据结构不同。自己写还是没写出来,本来还是想存成一个list然后转成string,但是怎么写都不对,最后还是向string(答案)屈服了。其实仔细想想也对,每个节点对应的path都应该也用一个queue/stack存起来,不然就要回溯remove它(但因为对每个节点都存所以感觉就巨麻烦),所以如果要用list的话得是a queue/stack of list,which太复杂了,不如直接用string了。
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<String> binaryTreePaths(TreeNode root) {
List<String> result = new ArrayList<>();
Queue<String> paths = new LinkedList<>();
Queue<TreeNode> queue = new LinkedList<>();
if (root == null) {
return result;
}
queue.add(root);
paths.add("");
while (!queue.isEmpty()) {
TreeNode node = queue.remove();
String str = paths.remove();
if (node.left == null && node.right == null) {
result.add(str + node.val);
}
if (node.left != null) {
queue.add(node.left);
paths.add(str + node.val + "->");
}
if (node.right != null) {
queue.add(node.right);
paths.add(str + node.val + "->");
}
}
return result;
}
}