代码随想录【Day14】｜二叉树的遍历（递归）、二叉树的遍历（非递归）

二叉树的遍历（递归）

144. 二叉树的前序遍历
94. 二叉树的中序遍历
145. 二叉树的后序遍历
题目描述：
二叉树结点的定义：

/**
 * Definition for a binary tree node.
 */
 public class TreeNode {
     int val;
     TreeNode left;
     TreeNode right;
     TreeNode() {}
     TreeNode(int val) { this.val = val; }
     TreeNode(int val, TreeNode left, TreeNode right) {
         this.val = val;
         this.left = left;
         this.right = right;
     }
 }

三个经典的二叉树递归遍历方法

//先序遍历
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        traversal(root, res);
        return res;
    }
    
    private void traversal(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }
        res.add(root.val);
        traversal(root.left, res);
        traversal(root.right, res);
    }
}

//中序遍历
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        traversal(root, res);
        return res;
    }

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

//后序遍历
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        traversal(root, res);
        return res;
    }

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

时长：
5min

收获：
牢记二叉树前中后三种遍历方法的顺序

---

二叉树的遍历（非递归）

144. 二叉树的前序遍历
94. 二叉树的中序遍历
145. 二叉树的后序遍历

题目描述：
“凡是用递归实现的都能用栈实现”
递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。

难点：
中序遍历（非递归）要特别注意
因为结点的访问顺序和处理顺序不一致！

//这里栈使用Deque实现，官方文档指出：
//When a deque is used as a stack, elements are pushed and popped from the beginning of the deque.

//先序遍历
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        Deque<TreeNode> stack = new ArrayDeque<>();
        List<Integer> result = new ArrayList<>();

        if (root == null) return result;
        stack.addFirst(root); //push
        while (!stack.isEmpty()) {
            TreeNode node = stack.removeFirst(); //pop
            result.add(node.val);
            if (node.right != null) {
                stack.addFirst(node.right);
            }
            if (node.left != null) {
                stack.addFirst(node.left);
            }
        }
        return result;
    }
}

//中序遍历
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        Deque<TreeNode> stack = new ArrayDeque<>();
        List<Integer> result = new ArrayList<>();

        if (root == null) return result;
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()) {
            if (cur != null) {
                stack.addFirst(cur); //push
                cur = cur.left;
            }else {
                cur = stack.removeFirst(); //pop
                result.add(cur.val);
                cur = cur.right;
            }
        }
        return result;
    }
}

//后序遍历
//与前序遍历“左中右”相反，是“左右中”。在前序遍历的代码上稍作修改即可。
//注意：左右孩子入栈顺序“左右”，出栈“右左”，得到“中右左”，将结果逆序即可
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        Deque<TreeNode> stack = new ArrayDeque<>();
        List<Integer> result = new ArrayList<>();

        if (root == null) return result;
        stack.addFirst(root); //push
        while (!stack.isEmpty()) {
            TreeNode node = stack.removeFirst(); //pop
            result.add(node.val);
            if (node.left != null) {
                stack.addFirst(node.left);
            }
            if (node.right != null) {
                stack.addFirst(node.right);
            }
        }
        Collections.reverse(result);
        return result;
    }
}

时长：
20min

收获：
Collections.reverse()方法没有返回值！

重点关注中序遍历的非递归方法，好好消化~