二叉树遍历方式归纳（java实现）

二叉树遍历方式归纳（java实现）加粗样式

学完二叉树后的知识点总结

0. 预先知识

0.1 遍历二叉树的几种顺序

前序：中左右

中序：左中右

后序：左右中

注：站在中间节点（根节点）的角度看

0.2 递归和迭代的区别

简单来说：

递归可以理解为自己调用自己；

迭代可以理解为旧值推新值。

递归三部曲：

• 确定递归函数的参数和返回值
• 确定终止条件
• 确定单层递归的逻辑

1. 递归遍历

1.1 前序遍历

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        preOrder(root, result);
        return result;
    }

    private void preOrder(TreeNode root, List<Integer> result) {
        if (root == null) {
            return;
        }
        result.add(root.val);
        preOrder(root.left, result);
        preOrder(root.right, result);
    }
}

1.2 中序遍历

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        midOrder(root, result);
        return result;
    }

    private void midOrder(TreeNode root, List<Integer> result) {
        if (root == null) {
            return;
        }
        midOrder(root.left, result);
        result.add(root.val);
        midOrder(root.right, result);
    }
}

1.3 后序遍历

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        postOrder(root, result);
        return result;
    }

    private void postOrder(TreeNode root, List<Integer> result) {
        if (root == null) {
            return;
        }
        postOrder(root.left, result);
        postOrder(root.right, result);
        result.add(root.val);
    }
}

2. 迭代遍历（深度优先）

2.1 前序遍历

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null)
            return result;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root); // 中
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            result.add(node.val);
            if (node.right != null) // 右
                stack.push(node.right);
            if (node.left != null) // 左
                stack.push(node.left);
        }
        return result;
    }
}

2.2 中序遍历

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

2.3 后序遍历

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

3. 层序遍历（广度优先）

class Solution {
        public List<List<Integer>> levelOrder(TreeNode root) {
            List<List<Integer>> result = new ArrayList<>();
            if (root == null)
                return result;
            Queue<TreeNode> queue = new LinkedList<>();
            queue.offer(root);
            while (!queue.isEmpty()) {
                int size = queue.size();
                List<Integer> tempList = new ArrayList<>();
                while (size > 0) {
                    TreeNode tempNode = queue.poll();
                    tempList.add(tempNode.val);
                    if (tempNode.left != null)
                        queue.add(tempNode.left);
                    if (tempNode.right != null)
                        queue.add(tempNode.right);
                    size--;
                }
                result.add(tempList);
            }
            return result;
        }
    }