LeetCode树的遍历高频题（十一）

大家好，我是方圆
无它，唯手熟尔

94. 二叉树的中序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();

        dfs(res,root);
        return res;
    }

    private void dfs(List<Integer> res,TreeNode root){
        //结束条件
        if(root == null){
            return;
        }

        //中序遍历，顺序是左子树，根节点，右子树
        dfs(res,root.left);
        res.add(root.val);
        dfs(res,root.right);
    }
}

102. 二叉树的层序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        //判空
        if(root == null){
            return new ArrayList<List<Integer>>();
        }

        List<List<Integer>> res = new ArrayList<>();
        LinkedList<TreeNode> queue = new LinkedList<>();
        //将根节点放入
        queue.add(root);

        while(queue.size() > 0){
            //size代表当前层的节点数
            int size = queue.size();

            //用tem来接收
            ArrayList<Integer> tem = new ArrayList<>();

            for(int i = 0; i < size;i++){
                //从队列中一个个拿出来，移除的是头节点
                TreeNode t = queue.remove();
                tem.add(t.val);

                //检查当前层的节点是不是还有左右节点
                if(t.left != null){
                    queue.add(t.left);
                }
                if(t.right != null){
                    queue.add(t.right);
                }
            }
            res.add(tem);
        }
        return res;
    }
}

110. 平衡二叉树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isBalanced(TreeNode root) {
        //这里我们用-1来代表不是平衡树的情况
        return recur(root) != -1;
    }

    private int recur(TreeNode root){
        //递归的终止条件，到达叶子节点返回0
        //表示树的高度从0开始增加
        if(root == null){
            return 0;
        }

        //对左子树的高度进行记录
        int left = recur(root.left);
        //返回值为-1时，则说明不是平衡树
        if(left == -1){
            return -1;
        }
        //对右子树同样的操作
        int right = recur(root.right);
        if(right == -1){
            return -1;
        }

        //当左右子树的高度差小于2的时候，返回树的高度,进行递增（+1）
        //否则，返回-1，不是平衡树
        return Math.abs(left - right) < 2 ? Math.max(left,right) + 1 : -1;
    }
}

144. 二叉树的前序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        //进行递归
        dfs(root,res);
        return res;
    }

    private void dfs(TreeNode root,List<Integer> res){
        //递归结束条件
        if(root == null){
            return;
        }

        //前序遍历的顺序，根节点，左节点，右节点
        res.add(root.val);
        dfs(root.left,res);
        dfs(root.right,res);
    }
}

145. 二叉树的后序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        dfs(root,res);
        return res;
    }

    private void dfs(TreeNode root,List<Integer> res){
        //递归的结束条件
        if(root == null){
            return;
        }

        //后序遍历的顺序是，左节点，右节点，根节点
        dfs(root.left,res);
        dfs(root.right,res);
        res.add(root.val);
    }
}

---

其实对于二叉树的前、中和后序遍历，有一个很明显的规律
前中后代表根节点的位置，即分别为根左右，左根右，左右根
而且对应代码中的add()方法的位置与前中后的位置也是一样的

这样就简单多了，边记边练！