1. 先序、中序、后序遍历递归

练习地址

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 the root of binary tree
     * @return int整型二维数组
     */
    public int[][] threeOrders (TreeNode root) {
        // write code here
        ArrayList<Integer> preRes = preOrder(root,new ArrayList<Integer> ());
        ArrayList<Integer> inRes = inOrder(root,new ArrayList<Integer> ());
        ArrayList<Integer> postRes = postOrder(root,new ArrayList<Integer> ());
        int[][] res = new int[3][preRes.size()];
        for(int i = 0;i<preRes.size();i++){
            res[0][i] = preRes.get(i);
            res[1][i] = inRes.get(i);
            res[2][i] = postRes.get(i);
        }
        return res;
    }
    
    //前序遍历：中、左、右
    public ArrayList<Integer> preOrder(TreeNode node,ArrayList<Integer> arr){
        if(node !=null){
            arr.add(node.val);
            preOrder(node.left,arr);
            preOrder(node.right,arr);
        }
        return arr;
    }
    
    //中序遍历：左、中、右
    public ArrayList<Integer> inOrder(TreeNode node,ArrayList<Integer> arr){
        if(node !=null){
            inOrder(node.left,arr);
            arr.add(node.val);
            inOrder(node.right,arr);
        }
        return arr;
    }
    
    //后序遍历：左、右、中
    public ArrayList<Integer> postOrder(TreeNode node,ArrayList<Integer> arr){
        if(node !=null){
            postOrder(node.left,arr);
            postOrder(node.right,arr);
            arr.add(node.val);
        }
        return arr;
    }
}

2. 层序遍历队列

练习地址

1. 使用队列来暂存每个层级的节点。
2. 先将根节点添加到队列中。
3. 当队列不为空时，遍历队列中的节点（此时队列中现存的节点，就是某一层所有的节点），因为在遍历过程中还会不断往队列中添加节点，所以在循环前，int size = queue.size();把队列的长度赋值给变量，固定下来，遍历时才不会遍历到其他层级的节点。
4. 获取队列中的节点，判空后可添加到该层级的list中，并同时将该节点的左右节点分别添加到列表。
5. 结束一层的遍历后，要先判断list的长度，再添加到最终结果中，防止添加了空List。

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @return int整型ArrayList<ArrayList<>>
     */
    public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root) {
        // write code here
        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while(!queue.isEmpty()){
            ArrayList<Integer> list = new ArrayList<Integer>();
            //一定要把size变量写在for循环外，因为queue是随着循环在变化的，因此需要在循环开始前就赋值
            int size = queue.size();
            for(int i=0;i<size;i++){
                TreeNode node = queue.poll();
                if(node != null){
                    list.add(node.val);
                    queue.offer(node.left);
                    queue.offer(node.right);
                }
            }
            if(list.size()>0){
                res.add(list);
            }
        }
        return res;
    }
}

3. 按之字顺序打印二叉树

练习地址

4. 在二叉树中找到两个节点的最近公共祖先

练习地址

5. 重建二叉树

练习地址

6. 二叉树最大深度递归

练习地址

递归解决，最大深度 = 1 + Math.max(左节点最大深度，右节点最大深度);

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @return int整型
     */
    public int maxDepth (TreeNode root) {
        if(root == null){
            return 0;
        }
        int left = maxDepth(root.left);
        int right = maxDepth(root.right);
        return 1+Math.max(left,right);
    }
}