二叉树四种遍历（递归+非递归）

一、先序遍历

思路：先输出当前节点，前序遍历左子树，前序遍历右子树

 //先序遍历
    //递归
    public static void  preOrder(BitNode root){
        root.visitNode();
        if(root.lchild != null)
            preOrder(root.lchild);
        if(root.rchild != null)
            preOrder(root.rchild);

    }
//非递归,先输出再入栈
    public static void preOrder1(BitNode root){
        Stack<BitNode> stack = new Stack<BitNode>();
        while(root != null || !stack.empty()){
            while(root != null){  //沿左孩子走到底，同时输出
                System.out.print(root.data+" ");
                stack.push(root);
                root = root.lchild;
            }
            if(!stack.empty()){  //出栈，并将非空右孩子入栈
                root = stack.pop();
                root = root.rchild;
            }

        }
    }

二、中序遍历

思路：中序遍历左子树，输出当前节点，中序遍历右子树

//中序遍历
    //递归
    public static void inOrder(BitNode root){
        if(root.lchild != null){
            inOrder(root.lchild);
        }
       root.visitNode();
        if(root.rchild != null){
            inOrder(root.rchild);
        }
    }
    //非递归,先入栈，后面先出栈再输出，出栈后将非空右孩子压入栈，空则继续弹出
    public static void inOrder1(BitNode root) {
        Stack<BitNode> stack = new Stack<>();
        while (root != null || !stack.empty()) {
            while (root != null) {
                stack.push(root);
                root = root.lchild;
            }
            if (!stack.empty()) {
                root = stack.pop();
                System.out.print(root.data+" ");
                root = root.rchild;
            }
        }
    }

三、后序遍历

思路：后序遍历左子树，后序遍历右子树，输出当前节点

//后序遍历
    //递归
    public static void postOrder(BitNode root){
        if(root.lchild != null){
            postOrder(root.lchild);
        }
        if(root.rchild != null){
            postOrder(root.rchild);
        }
        root.visitNode();
    }
    //非递归
    public static void postOrder1(BitNode root){
        Stack<BitNode> stack = new Stack<>();
        BitNode pre = null,cur;
        stack.push(root);
        while (!stack.empty()){
            cur = stack.peek();
            //若栈顶节点当前无左右节点则可输出并出栈，或者其左右节点被访问过（左节点：说明无右节点，右节点：说明有左右节点或者无左节点）
            if((cur.lchild == null && cur.rchild == null)||(pre != null && (pre == cur.lchild ||pre == cur.rchild))){
                cur.visitNode();
                stack.pop();
                pre = cur;
            }
            else {//注意顺序，先放入右节点，再放入左节点，后进先出
                if(cur.rchild != null)
                    stack.push(cur.rchild);
                if(cur.lchild != null)
                    stack.push(cur.lchild);
            }
        }

    }

四、层次遍历

思路：利用队列先进先出，左右孩子进入队列后，当前节点从队列中删除

 //层次遍历，根据队列来控制循环，出队并输出，将左右孩子入队
    // 首先将根节点入队，队列若不为空则出队一个节点并输出，然后判断其左右节点是否为空，不为空则则入队
    public static void levelTraverse(BitNode root){
        Queue<BitNode>  queue = new LinkedList<BitNode>();
        queue.offer(root);
        while(!queue.isEmpty()){
            BitNode bitNode = queue.poll();
            bitNode.visitNode();
            if(bitNode.lchild != null)
                queue.offer(bitNode.lchild);
            if(bitNode.rchild != null)
                queue.offer(bitNode.rchild);
        }
    }