LeetCode 872. Leaf-Similar Trees

原题链接在这里：https://leetcode.com/problems/leaf-similar-trees/

题目：

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.

Note:

• Both of the given trees will have between 1 and 100 nodes.

题解：

Use pre-order to get leaf one by one and compare the value.

Time Complexity: O(n). n is tree size.

Space: O(h). h is tree height.

AC Java:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean leafSimilar(TreeNode root1, TreeNode root2) {
        if(root1 == null || root2 == null){
            return root1 == root2;
        }
        
        Stack<TreeNode> stk1 = new Stack<>();
        Stack<TreeNode> stk2 = new Stack<>();
        stk1.push(root1);
        stk2.push(root2);
        while(!stk1.isEmpty() && !stk2.isEmpty()){
            int leaf1 = getLeafVal(stk1);
            int leaf2 = getLeafVal(stk2);
            if(leaf1 != leaf2){
                return false;
            }
        }
        
        return stk1.isEmpty() && stk2.isEmpty();
    }
    
    private int getLeafVal(Stack<TreeNode> stk){
        while(!stk.isEmpty()){
            TreeNode cur = stk.pop();
            if(cur.right != null){
                stk.push(cur.right);
            }
            
            if(cur.left != null){
                stk.push(cur.left);
            }
            
            if(cur.left == null && cur.right == null){
                return cur.val;
            }
        }
        
        return -1;
    }
}

AC JavaScript:

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root1
 * @param {TreeNode} root2
 * @return {boolean}
 */
var leafSimilar = function(root1, root2) {
    if(!root1 || !root2){
        return roo1 == root2;
    }
    
    var stk1 = [];
    var stk2 = [];
    stk1.push(root1);
    stk2.push(root2);
    
    while(stk1.length != 0 && stk2.length != 0){
        var leaf1 = getLeaf(stk1);
        var leaf2 = getLeaf(stk2);
        if(leaf1 != leaf2){
            return false;
        }
    }
    
    return stk1.length == 0 && stk2.length == 0;
};

var getLeaf = function(stk){
    while(stk.length != 0){
        var cur = stk.pop();
        if(cur.right){
            stk.push(cur.right);
        }
        
        if(cur.left){
            stk.push(cur.left);
        }
        
        if(!cur.left && !cur.right){
            return cur.val;
        }
    }
    
    return -1;
}