二叉树的前序、中序、后序的迭代算法实现

public static List<Integer> preOrder(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if (root == null) {
            return list;
        }

        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode get = stack.pop();
            list.add(get.value);
            //利用堆栈先进后出，先加入右子树
            if (get.right != null) {
                stack.push(get.right);
            }
            //再加入左子树
            if (get.left != null) {
                stack.push(get.left);
            }
        }

        return list;
    }

 //二叉树的中序遍历的迭代实现,利用 栈 模拟 递归过程
    public static List<Integer> infixOrder(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        //两个while语句
        TreeNode p = root;
        Stack<TreeNode> stack = new Stack<>();
        while (p != null || !stack.isEmpty()) {
            while (p != null) {//加入当前结点和当前结点的左子树
                stack.push(p);
                p = p.left;
            }

            p = stack.pop();
            list.add(p.value);//访问
            p = p.right;//访问右子树

        }

        return list;
    }

 //前序遍历为：根左右
    //后序遍历为：左右根
    //把前序遍历的左子树和右子树调换顺序，按前序遍历在逆序，就得出后序遍历的迭代
    public List<Integer> postOrderByPreOrder(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if (root == null) {
            return list;
        }

        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        TreeNode p = null;

        while (!stack.isEmpty()) {
            p = stack.pop();
            list.add(p.value);//访问根节点

            //调换左右的顺序
            //先进后出
            //左子树先进栈
            if (p.left != null) {
                stack.push(p.left);
            }
            //右子树再进栈，右子树先出栈
            if (p.right != null) {
                stack.push(p.right);
            }
        }

        return list;//结果反转就是后序遍历
    }

//后序遍历的迭代算法,一个节点出栈与否，跟它是否有右子树有关,
    // 没有右子树，则出栈；有右子树，但已访问过，也出栈；有右子树且未访问，访问右子树
    public List<Integer> postOrder(TreeNode root) {
        if (root == null) {//空二叉树
            return list;
        }

        TreeNode p = root;
        TreeNode last = null;//标志上一次访问的结点
        Stack<TreeNode> s = new Stack<>();

        while (p != null || !s.isEmpty()) {
            while (p != null) {
                s.push(p);//加入此结点和其左孩子
                p = p.left;
            }

            p = s.peek();
            //如果栈顶结点没有右子树或者右子树已经被访问过，则访问改节点
            if (p.right == null || (last != null && last == p.right)) {
                s.pop();
                list.add(p.value);
                last = p;//更新下一次的上一次访问结点
                p = null;
            } else {//有右子树且未访问，访问右子树
                p = p.right;
                last = null;
            }
        }

        return list;
    }