算法与数据结构-LeetCode-树

1	Minimum Depth of Binary Tree	最小深度：层序遍历，循环
2	binary-tree-postorder-traversal	后序遍历：递归
3	binary-tree-preorder-traversal	先序遍历：递归
4	sum-root-to-leaf-numbers	遍历，数学，递归
5	binary-tree-maximum-path-sum	先序遍历，循环，栈
6	populating-next-right-pointers-in-each-node-ii	层序遍历，循环，队列
7	populating-next-right-pointers-in-each-node	层序遍历，循环，队列
8	path-sum-ii	递归，数学计算
9	path-sum	递归，数学计算
10	balanced-binary-tree	递归，后序遍历
11	binary-tree-level-order-traversal-ii	从下往上的层序遍历，循环，栈，ArrayList逆序

12	construct-binary-tree-from-inorder-and-postorder-traversal	中序遍历+后序遍历 构造二叉树：后序list找根，中序List划分。 递归。
13	construct-binary-tree-from-preorder-and-inorder-traversal	先序遍历+后序遍历 构造二叉树：前序list找根，中序List划分。 递归。
14	maximum-depth-of-binary-tree	最大深度
15	binary-tree-zigzag-level-order-traversal	层序遍历循环+ArrayList的逆序
16	binary-tree-level-order-traversal	层序遍历，循环
17	symmetric-tree	层序遍历（左右）左子树，层序遍历（右左）右子树，直接比较每一个元素
18	same-tree	先序遍历，递归两棵树。同时比较相同节点的值
19	recover-binary-search-tree	中性遍历，递归，延续 validate-binary-search-tree，注意交换节点的两种情况，相邻，不相邻
20	validate-binary-search-tree	中序遍历，递归，法1：先变成List; 法2：直接比较
21	unique-binary-search-trees-ii	动态规划，递归，延续上题，unique-binary-search-trees
22	unique-binary-search-trees	动态规划，递归
23	binary-tree-inorder-traversal	中序遍历，递归

 

1. Minimum Depth of Binary Tree

Given a binary tree, find its minimum depth.The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

思路：层序遍历，循环，队列，每一个for里面就是一层，比较清晰

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
import java.util.LinkedList;
import java.util.Queue;
 
public class Solution {
    public int run(TreeNode root) {
        if(root==null){
            return 0;
        }
         
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        int depth = 0;
        while(queue.size()!=0){
            depth++;
            int qlength = queue.size();
             
            for(int i=0; i<qlength; i++){
                TreeNode t = queue.poll();
                if(t.left==null && t.right==null){
                    return depth;
                }
                if(t.left!=null && t.right!=null){
                    queue.offer(t.left);
                    queue.offer(t.right);
                }else if(t.left!=null && t.right==null){
                    queue.offer(t.left);
                }else if(t.left==null && t.right!=null){
                    queue.offer(t.right);
                }
            }
        }
        return 0;
    }
}

2. binary-tree-postorder-traversal

Given a binary tree, return the postorder traversal of its nodes' values.

For example:
Given binary tree{1,#,2,3},

   1
    \
     2
    /
   3

return[3,2,1].

Note: Recursive solution is trivial, could you do it iteratively?

后序遍历，递归

import java.util.ArrayList;
  
public class Solution {
      
    public ArrayList<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        if(root==null){
            return list;
        }
        postorderRecursive(root,list);
        return list;
    }
    public void postorderRecursive(TreeNode t, ArrayList<Integer> list){
        if(t.left!=null){
            postorderRecursive(t.left, list);
        }
        if(t.right!=null){
            postorderRecursive(t.right, list);
        }
        list.add(t.val);
          
        if(t.left==null && t.right==null){
            return;
        }
    }
}

后序遍历，循环，栈，【trick：前序遍历 根->左->右 变成 根->右->左 结果再reverse一下】

链接：https://www.nowcoder.com/questionTerminal/32af374b322342b68460e6fd2641dd1b
来源：牛客网

import java.util.ArrayList;
import java.util.Stack;
import java.util.Collections;
 
public class Solution {
     
    public ArrayList<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        if(root==null){
            return list;
        }
        TreeNode t = root;
        Stack<TreeNode> st = new Stack<TreeNode>();
        while(t!=null || !st.empty()){
            while(t!=null){
                list.add(t.val);
                st.push(t);
                t = t.right;
            }
            if(!st.empty()){
                t = st.pop();
                t = t.left;
            }
        }
        Collections.reverse(list);
        return list;
    }
}