Consider all the leaves of a binary tree, from left to right order, the values of those leaves form a leaf value sequence.
For example, in the given tree above, the leaf value sequence is (6, 7, 4, 9, 8)
.
Two binary trees are considered leaf-similar if their leaf value sequence is the same.
Return true
if and only if the two given trees with head nodes root1
and root2
are leaf-similar.
Example 1:
Input: root1 = [3,5,1,6,2,9,8,null,null,7,4], root2 = [3,5,1,6,7,4,2,null,null,null,null,null,null,9,8] Output: true
Example 2:
Input: root1 = [1,2,3], root2 = [1,3,2] Output: false
Constraints:
- The number of nodes in each tree will be in the range
[1, 200]
. - Both of the given trees will have values in the range
[0, 200]
.
题目要求两棵树所有的leaf从左到右是一样的就return true。
最最简单和无脑的做法就是用list按顺序存leaf,如果两个list一样的话就return true,否则return false。
递归版:
/**
* 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 boolean leafSimilar(TreeNode root1, TreeNode root2) {
List<Integer> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();
helper(root1, list1);
helper(root2, list2);
return list1.equals(list2);
}
private void helper(TreeNode root, List<Integer> list) {
if (root == null) {
return;
}
if (root.left == null && root.right == null) {
list.add(root.val);
}
helper(root.left, list);
helper(root.right, list);
return;
}
}
写迭代的时候直接写了个BFS,运行了才发现它是按层算的,所以会出现leaf从左到右的顺序不一致的情况,所以这题只能用DFS,这是个坑。
/**
* 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 boolean leafSimilar(TreeNode root1, TreeNode root2) {
List<Integer> list1 = helper(root1);
List<Integer> list2 = helper(root2);
return list1.equals(list2);
}
private List<Integer> helper(TreeNode root) {
List<Integer> list = new ArrayList<>();
if (root == null) {
return list;
}
Deque<TreeNode> stack = new ArrayDeque<>();
stack.push(root);
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
if (node.left == null && node.right == null) {
list.add(node.val);
}
if (node.left != null) {
stack.push(node.left);
}
if (node.right != null) {
stack.push(node.right);
}
}
return list;
}
}
还有一种优化的做法,来自:LeetCode - The World's Leading Online Programming Learning Platform
思路就是每次我们直接dfs到一个leaf去compare这个leaf是否相等,这样的话如果不相等就可以提前退出。需要两个stack来存两棵树的节点,对它们分别dfs找root的val,比较root的val是否相等。递归函数里采用while true的形式,每次pop取node,如果是leaf就直接return,否则接着push进stack并循环直到找到leaf为止。因此最好情况下空间复杂度就是O(h),h为树高。
/**
* 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 boolean leafSimilar(TreeNode root1, TreeNode root2) {
Deque<TreeNode> stack1 = new ArrayDeque<>();
Deque<TreeNode> stack2 = new ArrayDeque<>();
stack1.push(root1);
stack2.push(root2);
while (!stack1.isEmpty() && !stack2.isEmpty()) {
if (findLeafVal(stack1) != findLeafVal(stack2)) {
return false;
}
}
return stack1.isEmpty() && stack2.isEmpty();
}
private int findLeafVal(Deque<TreeNode> stack) {
while (true) {
TreeNode node = stack.pop();
if (node.left != null) {
stack.push(node.left);
}
if (node.right != null) {
stack.push(node.right);
}
if (node.left == null && node.right == null) {
return node.val;
}
}
}
}