二叉树前序、中序、后序遍历的迭代实现

二叉树的前序、中序、后序遍历用递归实现较为简单。本文记录几种迭代实现方式：

树节点定义：

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;
    }
}

前序遍历

前序遍历
先访问根节点，再访问左子树，最后右子树。中左右的顺序。

// 方法一：访问根节点，按栈的后进先出顺序，先右子树入栈，然后左子树入栈。
public List<Integer> preorderTraversal(TreeNode root) {
   List<Integer> ans = new ArrayList<>();
   if (root == null) {
       return ans;
   }
   Stack<TreeNode> stack = new Stack<>();
   stack.push(root);
   while (!stack.isEmpty()) {
       root = stack.pop();
       ans.add(root.val);
       if (root.right != null) {
           stack.push(root.right);
       }
       if (root.left != null) {
           stack.push(root.left);
       }
   }
   return ans;
}
// 方法二：先访问左侧节点，左侧访问完毕时，依次弹栈，从最下层开始访问右子树。
public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList<Integer>();
    if (root == null) {
        return res;
    }

    Deque<TreeNode> stack = new LinkedList<TreeNode>();
    TreeNode node = root;
    while (!stack.isEmpty() || node != null) {
        while (node != null) {
            res.add(node.val);
            stack.push(node);
            node = node.left;
        }
        node = stack.pop();
        node = node.right;
    }
    return res;
}

中序遍历

中序遍历
先访问左子树，再访问根节点，最后右子树。左中右的顺序。

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

后序遍历

后序遍历
先访问左子树，再访问右子树，最后根节点。左右中的顺序。

// 逆后序，左右中 ——> 中右左，再将结果作反转
public List<Integer> postorderTraversal(TreeNode root) {
    LinkedList<Integer> ans = new LinkedList<>();
    if (root == null) {
        return ans;
    }
    Deque<TreeNode> stack = new LinkedList<>();
    stack.push(root);
    while (!stack.isEmpty()) {
        root = stack.pop();
        // 结果反转，每次访问到的节点，添加到集合的头部
        ans.offerFirst(root.val);
        if (root.left != null) {
            stack.push(root.left);
        }
        if (root.right != null) {
            stack.push(root.right);
        }
    }
    return ans;
}

public List<Integer> postorderTraversal(TreeNode root) {
    LinkedList<Integer> ans = new LinkedList<>();
    if (root == null) {
        return ans;
    }
    Deque<TreeNode> stack = new LinkedList<>();
    TreeNode node = root;
    while (node != null || !stack.isEmpty()) {
        while (node != null) {
            ans.offerFirst(node.val);
            stack.push(node);
            node = node.right;
        }
        node = stack.pop();
        node = node.left;
    }
    return ans;
}