采用非递归方式遍历二叉树

public class BinaryTreeNonRecursion {

    
    public static void main(String[] args) {
        
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.left = new Node(6);
        root.right.right = new Node(7);
        root.left.right.left = new Node(8);
        root.left.right.right = new Node(9);
        
        postOrder(root);

    }
    
    
    /**
     * 后序遍历，左子树 -> 右子树   -> 根节点
     * 后序遍历的顺序倒过来就是 根节点-> 右子树 -> 左子树   
     * 在先序遍历的顺序是根节点 -> 左子树 -> 右子树  ，
     * 先序遍历是先压根节点 再压右子树，最后压左子树，把压左子树和右子树的顺序换一下，那打印的顺序就是根节点-> 右子树 -> 左子树，我用一个栈先保存，最后出栈时打印就是后序遍历了
     * 
     */
    public static void postOrder(Node  root) {
        Stack<Node> stack = new Stack<Node>();
        Stack<Node> stackPop = new Stack<Node>();
        stack.push(root);
        while(!stack.isEmpty()) {
            Node node = stack.pop();
            if(node != null) {
                stackPop.push(node);
                if(node.left != null) {
                    stack.push(node.left);
                }
                if(node.right != null) {
                    stack.push(node.right);
                }
            }
        }
        while(!stackPop.isEmpty()) {
            System.out.print(stackPop.pop().value+ " ");
        }
        
    }
    
    
    /**
     * 中序遍历，      左子树 ->  根节点   ->  右子树
     * @param root
     */
    public static void inOrder(Node root) {
        Stack<Node> stack = new Stack<Node>();
        //从根节点开始，根节点的左节点，左节点的左节点依次入栈
        stack.push(root);
        while(root.left != null) {
            stack.push(root.left);
            root= root.left;
        }
        while(!stack.isEmpty()) {
            Node temp = stack.pop();
            if(temp != null) {
                //栈顶元素出栈，打印该元素，
                System.out.print(temp.value + " ");
                //右子树不为空，右节点入栈
                if(temp.right != null) {
                    Node n1 = temp.right;
                    //右节点入栈
                    stack.push(temp.right);
                    //右节点的左节点，左节点的左节点入栈
                    while(n1.left != null) {
                        stack.push(n1.left);
                        n1 = n1.left;
                    }
                }
            }
        }
        
    }
    
    
    /**
     * 先序遍历      根节点   ->  左子树  ->  右子树
     * @param root
     */
    public static void preOrder(Node root) {
        //null可以进入栈里，并且没有限制
        Stack<Node> stack = new Stack<Node>();
        //根节点入栈
        stack.push(root);
        while(!stack.isEmpty()) {
            //栈顶元素出栈，打印该元素，
            Node temp = stack.pop();
            if(temp != null) {
                System.out.print(temp.value +" ");
                //右节点入栈
                if(temp.right != null) {
                    stack.push(temp.right);
                }
                //左节点入栈
                if(temp.left != null) {
                    stack.push(temp.left);    
                }
            }
        }
        
    }
    
    
    
    
    public static class Node {
        Node left;
        Node right;
        int value;

        public Node(int value) {
            this.value = value;
        }

    }
}