迭代方法遍历二叉树

1. 前序遍历

思路：

迭代方法（使用栈）：
（1）定义一个list集合ret保存返回值
（2）若root为空，直接返回ret
（3）初始化一个栈，把root赋给cur来遍历二叉树
（4）循环判断若cur不为空代表有节点，入栈，并添加到集合list中，“根左右”的根完成cur后移到左孩子节点，直到cur为空代表无左孩子，“根左右”的左完成
（5）此时栈顶就是左孩子的父节点，弹出栈顶赋给top，在让cur后移到右孩子节点，明显也得循环，此时用一个外层循环顺便包裹之前的循环，条件为cur不为空并且栈不为空（栈有元素就代表当前cur还有父节点），循环直到cur为空栈为空后，此时根节点也弹出了，返回ret

代码：

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

        while(cur != null || !stack.empty()){
            while(cur != null){
            stack.push(cur);
            ret.add(cur.val);
            cur = cur.left;
        }
        TreeNode top = stack.pop();
        cur = top.right;
        }
        return ret;
    }
}

2. 中序遍历

思路：和前序遍历就是放到集合的时机不一样

迭代方法（使用栈）：
（1）定义一个list集合ret保存返回值
（2）若root为空，直接返回ret
（3）初始化一个栈，把root赋给cur来遍历二叉树
（4）循环判断若cur不为空代表有节点，入栈，cur后移到左孩子节点，直到cur为空代表无左孩子，“左根右”的左完成
（5）此时栈顶就是左孩子的父节点，弹出栈顶赋给top，并把添加到集合list中，“左根右”的根完成，再让cur后移到右孩子节点，明显也得循环，此时用一个外层循环顺便包裹之前的循环，条件为cur不为空并且栈不为空（栈有元素就代表当前cur还有父节点），循环直到cur为空栈为空后，此时根节点也弹出了，返回ret

代码：

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> ret = new ArrayList<>();
        if(root == null){
            return ret;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;

        while(cur != null || !stack.empty()){
            while(cur != null){
            stack.push(cur);
            cur = cur.left;
        }
        TreeNode top = stack.pop();
        ret.add(top.val);
        cur = top.right;
        }
        return ret;
    }
}

3. 后序遍历

后序遍历就要考虑的更多一些了

思路：
迭代方法（使用栈）：
（1）定义一个list集合ret保存返回值
（2）若root为空，直接返回ret
（3）初始化一个栈，把root赋给cur来遍历二叉树
（4）循环判断若cur不为空代表有节点，入栈，cur后移到左孩子节点，直到cur为空代表无左孩子，“左右根”的左完成
（5）此时peek获取栈顶元素就是cur的父节点再赋给cur，判断若右孩子为空或右孩子已经放到集合中了，此时“左右根”的右完成，pop弹出栈顶元素放入集合中，时“左右根”的根完成，cur赋给prev记录此节点已经放过了，cur置为空（目的是此节点已经完成再次获取父节点）
（6）否则cur后移到右孩子，明显也得循环，此时用一个外层循环顺便包裹之前的循环，条件为cur不为空并且栈不为空（栈有元素就代表当前cur还有父节点），循环直到cur为空栈为空后，此时根节点也弹出了，返回ret

代码：
 

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