二叉树的迭代遍历（前，中，后）

目录

1、迭代方式的前序遍历

2、迭代方式的中序遍历

3、迭代方式的后续遍历

---

1、迭代方式的前序遍历

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList();
        if(root == null) {
            return res;
        }
        Stack<TreeNode> s = new Stack();

        while(root != null || !s.isEmpty()){
            while(root != null) {
                s.add(root);
                res.add(root.val);
                root = root.left;
            }
            root = s.peek();
            s.pop();
            root = root.right;
        }

        return res;
    }
}

思路：采用栈作为临时存储，从root到左边最后一个，每次while都加入结果集中，遍历到null，则开始遍历右边的节点，因为中间和左边的已加入到结果集中。

复杂度：O(n),每个节点都遍历了，空间复杂度O（H），因为栈存储大小的与二叉树的高度一样。

2、迭代方式的中序遍历

/**
 * 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> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList();
        if(root == null) {
            return res;
        }
        Stack<TreeNode> stack = new Stack();
        while(root != null || !stack.isEmpty()) {
            while(root != null) {
                stack.add(root);
                root = root.left;
            }
            root = stack.peek();
            res.add(root.val);
            stack.pop();
            root = root.right;
        }

        return res;
    }
}

思路：采用栈的方式保存每次最左的数据，左边为空后则保存栈顶的value，遍历栈顶node的右边节点，空的话走到上一级root，保存值，遍历root的右边的。

复杂度：O(n),每个节点都遍历了，空间复杂度O（H），因为栈存储大小的与二叉树的高度一样。

3、迭代方式的后续遍历

/**
 * 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> postorderTraversal(TreeNode root) {
            List<Integer> res = new ArrayList();
            if(root == null) {
                return res;
            }
            Stack<TreeNode> stack = new Stack();
            TreeNode pre = null;
            while(root != null || !stack.isEmpty()) {
                while(root != null) {
                    stack.push(root);
                    root = root.left;
                }
                root = stack.peek();
                if(root.right == null || root.right == pre) {
                    res.add(root.val);
                    stack.pop();
                    pre = root;
                    root = null;
                } else {
                    root = root.right;
                }
            }

            return res;
    }
}

思路：栈用来控制遍历到最左下的节点，记录值，然后下一轮遍历判断右子树，走到右边节点，遍历右子树，记录pre，再次peek，记录到了右子树已经遍历过，则直接遍历上层root

复杂度：O(n),每个节点都遍历了，空间复杂度O（H），因为栈存储大小的与二叉树的高度一样。