LeetCode: Tags-[Tree]

Tags：Tree

94. Binary Tree Inorder Traversal：https://leetcode.com/problems/binary-tree-inorder-traversal/

 中序遍历：

(解法1：递归； 利用addAll 或者 helper(root,rst);

解法2： 迭代； 首先cur记录root； while(cur!=null或!stack.empty())；1.内部while(cur!=null)，则push，cur向左迭代；2.出栈，添值，右；)

(注意：stack方法-push,pop,peek,empty();  queue方法-offer, poll, peek;)

① NLR：前序遍历(PreorderTraversal亦称（先序遍历））——访问根结点的操作发生在遍历其左右子树之前。

② LNR：中序遍历(InorderTraversal) ——访问根结点的操作发生在遍历其左右子树之中（间）。

③ LRN：后序遍历(PostorderTraversal) ——访问根结点的操作发生在遍历其左右子树之后。

Recursive解法：

一个错误解法: (只能遍历出根节点就return了，为什么不是左子树？dont know)

public class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> rst = new ArrayList<>();
        if (root.left != null) rst.add(inorderTraversal(root.left));
        rst.add(root.val);
        if (root.right != null) rst.add(inorderTraversal(root.right));
        return rst;
    }
}

解法1：利用Java方法addAll(List<>);

public class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> rst = new ArrayList<>();
        if (root == null) return rst;
        if (root.left != null) rst.addAll(inorderTraversal(root.left));
        rst.add(root.val);
        if (root.right != null) rst.addAll(inorderTraversal(root.right));
        return rst;
    }
}

解法2：helper()

(1.helper-null,left,add,right;  2.inorderTraversal-rst,helper,return;)

public class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> rst = new ArrayList<>();
        helper(root, rst);
        return rst;
    }
    public void helper(TreeNode root, List<Integer> rst) {
        if (root == null) return;
        helper(root.left, rst);
        rst.add(root.val);
        helper(root.right, rst);
    }
}

Iterative解法：<Stack>(4-2-6-1-3-5-null, 当cur!=null时, cur=cur.left遍历左子树, push; 当cur为null时跳出内while循环, 此时cur对于1的左子结点即null, stack里为1,2,4; pop1,cur=1; 接着cur=cur.right; 即已经pop和add了左节点和根节点, 再add右结点, 继续外循环, 如果cur=null, 仍然不执行内循环, 继续pop父节点2, right; 直到empty, 终止循环。所以外循环需要两个判断条件-cur=null或stack.empty)

 (1.rst,stack,cur;  2.while(||) while()-push,left; pop,add,right;  3.return)

public class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> rst = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode cur = root;
        while (cur != null || !stack.empty()) {
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.pop();
            rst.add(cur.val);
            cur = cur.right;
        }
        return rst;
    }
}

 

144. Binary Tree Preorder Traversal: https://leetcode.com/problems/binary-tree-preorder-traversal/

前序遍历：(放入root; while(!empty), 出栈，添值，右左入栈)

（注意出栈后记为cur，入栈是cur的left和right；别总写错成root）

Recursive：

public class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> rst = new ArrayList<>();
        helper(root, rst);
        return rst;
    }
    public void helper(TreeNode root, List<Integer> rst) {
        if (root == null) return;
        rst.add(root.val);
        helper(root.left, rst);
        helper(root.right, rst);
    }
}

Iterative：(初始stack放入root, cur=root, 每轮循环,pop出一个节点, 然后先push右节点, 再push左节点; 这样每次都add了左节点并且右节点一直在stack中记录着)

(1.rst,stack,if,push;  2.while(empty) cur,add,if-left,if-right;  3.return)

public class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> rst = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        if (root == null) return rst;
        stack.push(root);
        while (!stack.empty()) {
            TreeNode cur = stack.pop();
            rst.add(cur.val);
            if (cur.right != null) stack.push(cur.right);
            if (cur.left != null) stack.push(cur.left);
        }
        return rst;
    }
}

145. Binary Tree Postorder Traversal: https://leetcode.com/problems/binary-tree-postorder-traversal/

后序遍历：

解法1：(pre-NLR, post-LRN, 两种方法：一是先得到NRL再reverse，二是利用LinkedList.addFirst直接得到LRN)

public class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> rst = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        if (root == null) return rst;
        stack.push(root);
        while (!stack.empty()) {
            TreeNode cur = stack.pop();
            rst.add(cur.val);
            if (cur.left != null) stack.push(cur.left);
            if (cur.right != null) stack.push(cur.right);
        }
        Collections.reverse(rst);
        return rst;
    }
}

public class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        LinkedList<Integer> rst = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();
        if (root == null) return rst;
        stack.push(root);
        while (!stack.empty()) {
            TreeNode cur = stack.pop();
            rst.addFirst(cur.val);
            if (cur.left != null) stack.push(cur.left);
            if (cur.right != null) stack.push(cur.right);
        }
        return rst;
    }
}

public List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> list = new ArrayList<>();
    if(root == null) return list;
    Stack<TreeNode> stack = new Stack<>();
    stack.push(root);
    while(!stack.empty()){
        root = stack.pop();
        list.add(0, root.val);
        if(root.left != null) stack.push(root.left);
        if(root.right != null) stack.push(root.right);
    }
    return list;
}

解法2：(使用pre记录路径, 分三种情况，第一种：如果pre=null或者pre.left/right=cur, 那么是往下遍历, push左树(push完所有左节点), 再push右树； 第二种情况：cur.left=pre, 那么说明是从左树往上遍历, push右树; 第三种情况：可能出现prev=cur或者cur.right=pre, 说明已经到左尾节点或者从右树往上遍历,所以需要add和pop;  总的还是先push左根节点，再在每一个左节点上操作--如果往下遍历则遍历右节点，如果往上遍历则add；)

public ArrayList<Integer> postorderTraversal(TreeNode root) {
    ArrayList<Integer> result = new ArrayList<Integer>();
    Stack<TreeNode> stack = new Stack<TreeNode>();
    TreeNode prev = null; // previously traversed node
    TreeNode curr = root;

    if (root == null) {
        return result;
    }

    stack.push(root);
    while (!stack.empty()) {
        curr = stack.peek();
        if (prev == null || prev.left == curr || prev.right == curr) { // traverse down the tree
            if (curr.left != null) {
                stack.push(curr.left);
            } else if (curr.right != null) {
                stack.push(curr.right);
            }
        } else if (curr.left == prev) { // traverse up the tree from the left
            if (curr.right != null) {
                stack.push(curr.right);
            }
        } else { // traverse up the tree from the right
            result.add(curr.val);
            stack.pop();
        }
        prev = curr;
    }

    return result;
}

95. Unique Binary Search Trees II：https://leetcode.com/problems/unique-binary-search-trees-ii/

生成所有1-n的二叉树：

解法：<Recursive>(对于1-n的数，选择i作为根节点，那么左子树是所有1到i-1的树，右子树是所有i+1到n的树，可以用递归求解。例如1-3，当root=1时，左子树1-0，null，右子树为2-3的两种情况；root=2时，左子树为1-1，右子树为2-2；root=3时，左子树1-2，右子树4-3null；所以可以归纳当start>end的时候为null，start=end的时候可以归并到start<end的左右子树情况。即分别遍历左右子树)

(1.helper(1,n);  2.rst,if(>)null,return;  3.for(start,end),left,right;  4.for(l)for(r)root,left,right,add;  5.return rst;)

public class Solution {
    public List<TreeNode> generateTrees(int n) {
        if (n == 0) return new ArrayList<TreeNode>();
        return helper(1,n);
    }
    public List<TreeNode> helper(int start, int end){
        List<TreeNode> rst = new ArrayList<>();
        if (start > end) {
            rst.add(null);
            return rst;
        }

        for (int i = start; i <= end; i++) {
            List<TreeNode> left = helper(start, i - 1);
            List<TreeNode> right = helper(i + 1, end);
            for (TreeNode l : left) { 
                for (TreeNode r : right) {
                    TreeNode root = new TreeNode(i);
                    root.left = l;
                    root.right = r;
                    rst.add(root);
                }
            }
        }
        return rst;
    }
}

96. Unique Binary Search Trees：https://leetcode.com/problems/unique-binary-search-trees/

1-n的二叉树的个数：

我的Recursive解法: (1-18可以pass, 大于19就TLE了)

public class Solution {
    public int numTrees(int n) {
        if (n == 0 || n == 1) return 1;
        int rst = 0;
        for (int i = 0; i < n; i++) {
            rst = rst + numTrees(n - i - 1) * numTrees(i) ;
        }
        return rst;
    }
}

改进：(将数都保存到数组里, 两次for循环。思想是相同的，都是找出n的规律。G(n) = G(0) * G(n-1) + G(1) * G(n-2) + … + G(n-1) * G(0))

(1.int[n+1],[0],[1];  2.for(2,n)for(0,i),[i]+=[j]*[i-j-1];  3.return)

public class Solution {
    public int numTrees(int n) {
        int[] rst = new int[n + 1];
        rst[0] = rst[1] = 1;
        for (int i = 2; i <= n; i++) {
            for (int j = 0; j < i; j++) {
                rst[i] += rst[j] * rst[i - j - 1];
            }
        }
        return rst[n];
    }
}

98. Validate Binary Search Tree: https://leetcode.com/problems/validate-binary-search-tree/

验证二叉树：

解法1：(中序遍历思想,Inorder遍历出来的顺序就是升序的, 使用pre记录前一个数, 如果>=cur则错误)

(1.stack,cur,pre;  2.while(||) while()push,left;  3.pop,if(&&)-false, pre,left;  4.return true)

public class Solution {
    public boolean isValidBST(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        TreeNode pre = null;
        while (cur != null || !stack.empty()) {
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.pop();
            if (pre != null && pre.val >= cur.val) return false;
            pre = cur;
            cur = cur.right;
        }
        return true;
    }
}

解法2：(Recursive, 每一个node判断是否处于其范围内，及左节点小于父节点的值，又节点大于父节点的值)

(1.helper(,MAX,MIN);  2.helper: null; if(||); return&&;)

public class Solution {
    public boolean isValidBST(TreeNode root) {
        return helper(root, Long.MIN_VALUE, Long.MAX_VALUE);
    }
    public boolean helper(TreeNode root, long lo, long hi) {
        if (root == null) return true;
        if (root.val >= hi || root.val <= lo) return false;
        return helper(root.left, lo, root.val) && helper(root.right, root.val, hi);
    }
}

100. Same Tree： https://leetcode.com/problems/same-tree/

判断两树是否相同：

Recursive解法：

(1.&null;  2.if(!=null & val),return left&right;  3.return false)

public class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if (p == null && q == null) return true;
        if (p != null && q !=null && p.val == q.val)
            return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
        return false;
    }
}

101. Symmetric Tree: https://leetcode.com/problems/symmetric-tree/

对称树：

解法1：Recursive

(1.null,helper();  2.helper: if(||)return==,  if(val)-false,  return&&)

public class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) return true;
        return helper(root.left, root.right);
    }
    public boolean helper(TreeNode left, TreeNode right) {
        if (left == null || right == null) return left == right;
        if (left.val != right.val) return false;
        return helper(left.left, right.right) && helper(left.right, right.left);
    }
}

解法2：Iterative(Stack. 例：1,2,2,3,4,4,3; 先push进root.left/right; 判断都为null-continue, 其中一个null或者值不等-false; 然后push进左右节点的四个子节点,在栈中的顺序依次是右左右左4433; 此时pop出两个4,不在判断语句范围内, push进4的left/right即为4个null,此时栈中null*4+33, pop出4个null都continue了,再继续判断33; 满足就return false; 关键点是stack可以push进null, 而且null被pop出后不会有影响。每次pop出最后一个叶节点后就会push进它的null子节点, 算是终止标志了。)

(1.if,stack,push;  2.while(),n1,n2;  3.if(&&)continue;  4.if(null||val)false;  5.push*4l;  6.return true)

public class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) return true;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root.left);
        stack.push(root.right);
        while (!stack.empty()) {
            TreeNode n1 = stack.pop(), n2 = stack.pop();
            if (n1 == null && n2 == null) continue;
            if (n1 == null || n2 == null || n1.val != n2.val) return false;
            stack.push(n1.right);
            stack.push(n2.left);
            stack.push(n1.left);
            stack.push(n2.right);
        }
        return true;
    }
}

Home   OJ   Symmetric Tree   Recursive and non-recursive solutions in Java 
New users please read the instructions to format your code properly. Discuss is a place to post interview questions or share solutions / ask questions related to OJ problems.
Recursive and non-recursive solutions in Java

159
L lvlolitte 
Reputation:  506
Recursive--400ms:

public boolean isSymmetric(TreeNode root) {
    return root==null || isSymmetricHelp(root.left, root.right);
}

private boolean isSymmetricHelp(TreeNode left, TreeNode right){
    if(left==null || right==null)
        return left==right;
    if(left.val!=right.val)
        return false;
    return isSymmetricHelp(left.left, right.right) && isSymmetricHelp(left.right, right.left);
}
Non-recursive(use Stack)--460ms:

public boolean isSymmetric(TreeNode root) {
    if(root==null)  return true;
    
    Stack<TreeNode> stack = new Stack<TreeNode>();
    TreeNode left, right;
    if(root.left!=null){
        if(root.right==null) return false;
        stack.push(root.left);
        stack.push(root.right);
    }
    else if(root.right!=null){
        return false;
    }
        
    while(!stack.empty()){
        if(stack.size()%2!=0)   return false;
        right = stack.pop();
        left = stack.pop();
        if(right.val!=left.val) return false;
        
        if(left.left!=null){
            if(right.right==null)   return false;
            stack.push(left.left);
            stack.push(right.right);
        }
        else if(right.right!=null){
            return false;
        }
            
        if(left.right!=null){
            if(right.left==null)   return false;
            stack.push(left.right);
            stack.push(right.left);
        }
        else if(right.left!=null){
            return false;
        }
    }
    
    return true;
}

102. Binary Tree Level Order Traversal: https://leetcode.com/problems/binary-tree-level-order-traversal/

层序遍历：

解法1：<BFS> <Queue>(for循环遍历每层节点，左右节点不为null则offer进queue；每趟循环poll出该层节点add进list里。ps:queue是接口，不能实例化，只能通过已经存在的实现比如LinkedList。Stack有方法empty(); queue的LinkedList继承了List的isEmpty()方法；)

(1.queue,rst,if(),offer;  2.while(),list,size;  3.for(),poll,list,if()-offer, rst  4.return)

public class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> rst = new ArrayList<>();
        if (root == null) return rst;
        queue.offer(root);
        while (!queue.isEmpty()) {
            List<Integer> list = new ArrayList<>();
            int size = queue.size();
            for (int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                list.add(node.val);
                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
            }
            rst.add(list);
        }
        return rst;
    }
}

解法2: <DFS> <Recursive>(定义helper(rst,root,heght), rst.get(height).add(rot.val), 递归)

public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        levelHelper(res, root, 0);
        return res;
    }
    
    public void levelHelper(List<List<Integer>> res, TreeNode root, int height) {
        if (root == null) return;
        if (height >= res.size()) {
            res.add(new LinkedList<Integer>());
        }
        res.get(height).add(root.val);
        levelHelper(res, root.left, height+1);
        levelHelper(res, root.right, height+1);
    }

103. Binary Tree Zigzag Level Order Traversal: https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/

曲折层序遍历(每层依次左右、右左、左右……)：

我的解法：<BFS>(和层序遍历方法相同。增加了count作为计数。count=1的时候add(val)，然后count置零。else-add(0,val),count-1;)

(1.rst,queue,null,offer,count;  2.while(),size,list;  3.if(1)for(),node,add,offer,0;  4.if(0),add(0,val);  5.rst.add;return)

public class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> rst = new LinkedList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        if (root == null) return rst;
        queue.offer(root);
        int count = 1;
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> list = new LinkedList<>();
            if (count == 1) {
                for (int i = 0; i < size; i++) {
                    TreeNode node = queue.poll();
                    list.add(node.val);
                    if (node.left != null) queue.offer(node.left);
                    if (node.right != null) queue.offer(node.right);
                }
                count = 0;
            } else {
                for (int i = 0; i < size; i++) {
                    TreeNode node = queue.poll();
                    list.add(0, node.val);
                    if (node.left != null) queue.offer(node.left);
                    if (node.right != null) queue.offer(node.right);
                }
                count = 1;
            }
            rst.add(list);
        }
        return rst;
    }
}

改进：(1.rst,queue,null,offer,order;  2.while(),size,list;  3.for(),node,if-add,else-add(0),offer;  4.order,rst;return;)

public class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> rst = new LinkedList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        if (root == null) return rst;
        queue.offer(root);
        boolean order = true;
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> list = new LinkedList<>();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (order) {
                    list.add(node.val);
                } else {
                    list.add(0, node.val);
                }
                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
            }
            order = !order;
            rst.add(list);
        }
        return rst;
    }
}

解法2：<DFS>

public class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) 
    {
        List<List<Integer>> sol = new ArrayList<>();
        travel(root, sol, 0);
        return sol;
    }
    
    private void travel(TreeNode curr, List<List<Integer>> sol, int level)
    {
        if(curr == null) return;
        
        if(sol.size() <= level)
        {
            List<Integer> newLevel = new LinkedList<>();
            sol.add(newLevel);
        }
        
        List<Integer> collection  = sol.get(level);
        if(level % 2 == 0) collection.add(curr.val);
        else collection.add(0, curr.val);
        
        travel(curr.left, sol, level + 1);
        travel(curr.right, sol, level + 1);
    }
}

104. Maximum Depth of Binary Tree: https://leetcode.com/problems/maximum-depth-of-binary-tree/

最大深度：

我的解法：<Recursive><Greedy>

(1.null,0;  2.rst,Math.max;  3.return rst+1)

public class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) return 0;
        int rst = Math.max(maxDepth(root.left), maxDepth(root.right));
        return rst + 1;
    }
}

解法2：<BFS>(Level Order Traverse思想)

public int maxDepth(TreeNode root) {
    if(root == null) {
        return 0;
    }
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    int count = 0;
    while(!queue.isEmpty()) {
        int size = queue.size();
        while(size-- > 0) {
            TreeNode node = queue.poll();
            if(node.left != null) {
                queue.offer(node.left);
            }
            if(node.right != null) {
                queue.offer(node.right);
            }
        }
        count++;
    }
    return count;
}

107. Binary Tree Level Order Traversal II：https://leetcode.com/problems/binary-tree-level-order-traversal-ii/

层序遍历II-页到根顺序：

我的解法：(与Level Order Traverse 方法相同。队列。利用LinkedList的addFirst方法。ps：rst为List<List<>>时不存在addFirst方法, 必须是LinkdeList<List<>>。也可以用ArrayList和LinkedList的add(index, E)的方法)

public class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        LinkedList<List<Integer>> rst = new LinkedList<>();
        if (root == null) return rst;
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> list = new LinkedList<>();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                list.add(node.val);
                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
            }
            rst.addFirst(list);
        }
        return rst;
    }
}

解法2：DFS

public class Solution {
        public List<List<Integer>> levelOrderBottom(TreeNode root) {
            List<List<Integer>> wrapList = new LinkedList<List<Integer>>();
            levelMaker(wrapList, root, 0);
            return wrapList;
        }
        
        public void levelMaker(List<List<Integer>> list, TreeNode root, int level) {
            if(root == null) return;
            if(level >= list.size()) {
                list.add(0, new LinkedList<Integer>());
            }
            levelMaker(list, root.left, level+1);
            levelMaker(list, root.right, level+1);
            list.get(list.size()-level-1).add(root.val);
        }
    }

110. Balanced Binary Tree：https://leetcode.com/problems/balanced-binary-tree/

平衡二叉树(两个子树的深度差不超过1)：

解法1：(利用方法depth，要求两个子树深度差小于1且两个子树均为平衡树)

(1.if,rst,return 1&& ;  2.depth(),if-0,rst,return rst+1)

public class Solution {
    public boolean isBalanced(TreeNode root) {
        if (root == null) return true;
        int rst = Math.abs(depth(root.left) - depth(root.right));
        return (rst <= 1) && isBalanced(root.left) && isBalanced(root.right);
    }
    public int depth(TreeNode root) {
        if (root == null) return 0;
        int rst = Math.max(depth(root.left), depth(root.right));
        return rst + 1;
    }
}

解法2：(只遍历一次 用-1记录不平衡的子树;相当于自底向上遍历。解法1中首先root求左右深度O(N), 然后每个节点都要求左右深度, 所以是O(NlogN)? 而解法2每次返回节点的高度或者-1 最后判断值是否是-1即可,O(N))

(1.return !=-1;  2.height: lh-if,rh-if; if(>1); return max()+1;)

public class Solution {
    public boolean isBalanced(TreeNode root) {
        return height(root) != -1;
    }
    public int height(TreeNode root) {
        if (root == null) return 0;
        int lh = height(root.left);
        if (lh == -1) return -1;
        int rh = height(root.right);
        if (rh == -1) return -1;
        if (Math.abs(lh - rh) > 1) return -1;
        return Math.max(lh, rh) + 1;
    }
}

111. Minimum Depth of Binary Tree：https://leetcode.com/problems/minimum-depth-of-binary-tree/

最小深度：

我的解法：<Recursive><DFS>(和maxDepth相比，一个特殊点就是当left为null的时候而right不为null时，需要继续遍历right，选择叶节点作为终点——即左右节点都不为null。所以可以添加语句：left==null，则返回min(right)+1; 例如：[1,null,3,4]-return3; [1,null,3,4,5,6]-return3;)

(1.root,left,right;  2.rst,return)

public class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) return 0;
        if (root.left == null) return minDepth(root.right) + 1;
        if (root.right == null) return minDepth(root.left) + 1;
        int rst = Math.min(minDepth(root.left), minDepth(root.right));
        return rst + 1;
    }
}

我的解法2: <BFS><Level Order Traverse>(层序遍历思想。和maxDepth的区别是，遇到left和right都为null的时候就return count；而有不为null的则继续遍历cnt++)

(1.root,queue,offer,count1; 2.while()size,poll; 3.for()node,if(&&)count,if(!=); 4.count++,return)

public class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) return 0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int count = 1;
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.left == null && node.right == null) return count;
                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
            }
            count++;
        }
        return count;
    }
}

112. Path Sum: https://leetcode.com/problems/path-sum/

判断是否存在根到叶路径经过的值的和等于给定值：

我的解法：<Recursive>(1-2-3-null-4,sum=7为例; root==null的时候是判false的，刚开始我是return sum==0；其实不可以。首先1，左右节点都不为null，递归到2和3；2-6，3-6，对与2，左节点为null，右节点为4，因为它的左右节点没有都为null，所以它不是叶节点，要继续递归！对于3，已经是页节点，return 3==6； 2继续递归，左节点为null，return false！而不是return sum = 0的！因为只有当子节点有一个为null的时候才会存在判断null的情况，那么它不是叶节点，return false，利用val=sum判断另一个节点是否符合。注意：节点值和sum值都是可负的，不要多此一举添加sum<0的判断.PS:leetcode的testcase也很迷，第一次提交beat9%，第二次提交beat99%……)

(1.if(null); 2.if(&&)=; 3.return&&;)

public class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if (root == null) return false;
        if (root.left == null && root.right == null) return root.val == sum;
        return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
    }
}

113. Path Sum II：https://leetcode.com/problems/path-sum-ii/

返回路径值：

解法1：<Recursion>(和数组里子集的题类似。每次add进当前值，递归left和right，再remove即返回上一节点。终止条件是叶节点--及左右子节点都为null，如果=val了，那么add，remove，return；否则return；)

(1.rst,list,helper,return;  2.helper: if(root);  3.if(left,right);if(=)-add,add,remove;return 4.add,helper,remove)

public class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        List<List<Integer>> rst = new ArrayList<>();
        List<Integer> list = new ArrayList<>();
        helper(root, sum, list, rst);
        return rst;
    }
    public void helper(TreeNode root, int sum, List<Integer> list, List<List<Integer>> rst) {
        if (root == null) return;
        if (root.left == null && root.right == null) {
            if (root.val == sum) {
                list.add(root.val);
                rst.add(new ArrayList<Integer>(list));
                list.remove(list.size() - 1);
            }
            return;
        }
        list.add(root.val);
        helper(root.left, sum - root.val, list, rst);
        helper(root.right, sum - root.val, list, rst);
        list.remove(list.size() - 1);
    }
}

226. Invert Binary Tree: https://leetcode.com/problems/invert-binary-tree/

反转二叉树：

我的解法：<Recursive>(利用tmp和常规swap方法+Recursive。需要root==null的判断情况。例如：[4,2,7,1,null,null,9])

(1.heler;  2.helper:if(root);  3.tmp,left,right;  4.return root)

public class Solution {
    public TreeNode invertTree(TreeNode root) {
        return helper(root);
    }
    public TreeNode helper(TreeNode root) {
        if (root == null) return root;
        TreeNode tmp = helper(root.right);
        root.right = helper(root.left);
        root.left = tmp;
        return root;
    }
}

public TreeNode invertTree(TreeNode root) {
        if (root == null) return null;
        TreeNode tempRight = root.right;
        root.right = invertTree(root.left);
        root.left = invertTree(tempRight);
        return root;
    }

上面解法是从下往上swap，也可以从上往下：

public class Solution {
    public TreeNode invertTree(TreeNode root) {
        
        if (root == null) {
            return null;
        }

        final TreeNode left = root.left,
                right = root.right;
        root.left = invertTree(right);
        root.right = invertTree(left);
        return root;
    }
}

解法2：<Iterative>(Level Order层序遍历思想，从上往下的方法改为用栈来实现。)

(1.if,queue,offer;  2.while,poll,swap;  3.if-offer;  4.return)

public class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) return null;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            //swap;
            TreeNode tmp = node.right;
            node.right = node.left;
            node.left = tmp;
            //offer;
            if (node.left != null) queue.offer(node.left);
            if (node.right != null) queue.offer(node.right);
        }
        return root;
    }
}

235. Lowest Common Ancestor of a Binary Search Tree: https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/

BST-两个节点的最低的同祖先节点：

解法：(利用二叉搜索树BST性质--左子树小于root，右子树大于root；往下遍历确保两个节点在同一子树。else情况包括分别大于和小于root；或者其中一个等于root。PS：二叉树只是普通的左右指针树，二叉搜索数才有大小性质)

Recursive:

public class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root.val > p.val && root.val > q.val){
            return lowestCommonAncestor(root.left, p, q);
        }else if(root.val < p.val && root.val < q.val){
            return lowestCommonAncestor(root.right, p, q);
        }else{
            return root;
        }
    }
}

Non-Recursive：

(1.while(true);  2.if(<)left, elseif(>)right,else-break;  3.return)

public class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        while (true) {
            if (p.val < root.val && q.val < root.val) root = root.left;
            else if (p.val > root.val && q.val > root.val) root = root.right;
            else break;
        }
        return root;
    }
}

public class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        while (true) {
            if (root.val > p.val && root.val > q.val)
                root = root.left;
            else if (root.val < p.val && root.val < q.val)
                root = root.right;
            else
                return root;
        }
    }
}

257. Binary Tree Paths：https://leetcode.com/problems/binary-tree-paths/

二叉树的所有路径(路径为字符串)：

解法1：<Recursive>(helper，终止条件是：叶节点。)

(1.rst,if(!=),helper; 2.helper: if(&&)add, if(!=)helper)

public class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> rst = new ArrayList<>();
        if(root != null) helper(root, "", rst);
        return rst;
    }
    public void helper(TreeNode root, String str, List<String> rst) {
        if (root.left == null && root.right == null) rst.add(str + root.val);
        if (root.left != null) helper(root.left, str + root.val + "->", rst);
        if (root.right != null) helper(root.right, str + root.val + "->", rst);
    }
}

404. Sum of Left Leaves: https://leetcode.com/problems/sum-of-left-leaves/

所有左叶节点的和：

解法1：<Recursive>(左节点不为null，如果为叶则add，否则递归；右节点不为null，递归。 刚开始用helper(root,sum)做，结果不正确，好像是被重复加了)

(1.if,sum;  2.if(left),if(&&)-val,else-Rec;  3.if(right)-Rec;  4.return)

public class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if (root == null) return 0;
        int sum = 0;
        if (root.left != null) {
            if (root.left.left == null && root.left.right == null) {
                sum += root.left.val;
            } else {
                sum += sumOfLeftLeaves(root.left);
            }
        }
        if (root.right != null) {
            sum += sumOfLeftLeaves(root.right);
        }
        return sum;
    }
}

public int sumOfLeftLeaves(TreeNode root) {
    if(root == null) return 0;
    int ans = 0;
    if(root.left != null) {
        if(root.left.left == null && root.left.right == null) ans += root.left.val;
        else ans += sumOfLeftLeaves(root.left);
    }
    ans += sumOfLeftLeaves(root.right);
    
    return ans;
}

解法2：<Iterative>

public int sumOfLeftLeaves(TreeNode root) {
    if(root == null) return 0;
    int ans = 0;
    Stack<TreeNode> stack = new Stack<TreeNode>();
    stack.push(root);
    
    while(!stack.empty()) {
        TreeNode node = stack.pop();
        if(node.left != null) {
            if (node.left.left == null && node.left.right == null)
                ans += node.left.val;
            else
                stack.push(node.left);
        }
        if(node.right != null) {
            if (node.right.left != null || node.right.right != null)
                stack.push(node.right);
        }
    }
    return ans;
}

437. Path Sum III: https://leetcode.com/problems/path-sum-iii/