二叉树的非递归 先序，中序，后序，层序遍历

//前序递归遍历
 public void preOrderTraverse() {
        //输出根节点值
        if (root != null) {
            System.out.print(root.value + "--");
            //对左子树先序遍历
            //构建一个二叉树，根是左子树的根
            IBinaryTree leftTree = new LinkedBinaryTreeImpl(root.leftChild);
            leftTree.preOrderTraverse();
            //对右子树先序遍历
            //构建一个二叉树，根是左子树的根
            IBinaryTree rightTree = new LinkedBinaryTreeImpl(root.rightChild);
            rightTree.preOrderTraverse();
        }
    }
    

递归的前序，中序，后序遍历基本相同，只需交换输出和遍历左右子节点的顺序即可
这里就不在赘述。

前序非递归遍历–>利用栈完成

 public void preOrderByStack() {
        Stack<Node> stack = new Stack<>();
        stack.push(root);
        while(stack != null) {
            Node cur = stack.pop();
            System.out.println(cur.value);
            if(cur.rightChild != null) {
                stack.push(cur.rightChild);
            }
            if(cur.leftChild != null) {
                stack.push(cur.leftChild);
            }
        }
    }

中序非递归遍历–>利用栈完成

 public void midOrderByStack() {
        System.out.println("非递归中序遍历---");
        Deque<Node> stack = new LinkedList<Node>();
        Node current = root;
        while(current != null || !stack.isEmpty()) {
            while(current != null) {
                stack.push(current);
                current = current.leftChild;
            }
            if(!stack.isEmpty()) {
                current = stack.pop();
                System.out.print(current.value + "--");
                //进入右子树，开始新的一轮左子树遍历(这是递归的自我实现)
                current = current.rightChild;
            }
        }
        System.out.println();
    }

非递归后序遍历–>利用一个辅助栈完成，每次s1出栈时，入栈到s2中，此时s2出栈后就是后序遍历

    public void postOrderByStack() {
        System.out.println("非递归后序遍历---");
        Deque<Node> s1 = new LinkedList<>();
        Deque<Node> s2 = new LinkedList<>();
        s1.push(root);
        Node temp = root;
        while (!s1.isEmpty()) {
            Node cur = s1.pop();
            s2.push(cur);

            if (cur.leftChild != null)
                s1.push(cur.leftChild);
            if (cur.rightChild != null)
                s1.push(cur.rightChild);
        }
        while(!s2.isEmpty()) {
            System.out.println(s2.pop().value()+"--");
        }
    }

层序遍历–>利用队列完成遍历

    public void levelOrderbyStack() {
        System.out.println("按照层次遍历二叉树---");
        if (root == null) return;
        Queue<Node> queue = new LinkedList<Node>();
        queue.add(root);
        while (queue.size() != 0) {
            int len = queue.size();
            for (int i = 0; i < len; i++) {
                Node temp = queue.poll();
                System.out.println(temp.value + "--");
                if (temp.leftChild != null)
                    queue.add(temp.leftChild);
                if (temp.rightChild != null)
                    queue.add(temp.rightChild);
            }
        }
    }