二叉树-遍历

二叉树节点结构

public class Node<V> {
    V value;
    Node left;
    Node right;

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

递归遍历

/**
     * 前中后序只是打印的位置不一样
     * 涉及概念： 递归序
     */
    public static void digui(Node head){
        if (head==null){
            return;
        }

        //前序遍历在这输出  System.out.print(head.value + "  ->  ");
        digui(head.left);

        //中序遍历在这输出 System.out.print(head.value + "  ->  ");
//       
        digui(head.right);

        //后续遍历在这输出
        System.out.print(head.value + "  ->  ");
    }

非递归-前序遍历

public static void pre_order(Node head){
        Stack<Node> stack = new Stack<>();

        if (head==null){
            return;
        }
        //1。 头节点入栈
        stack.add(head);
        while (!stack.isEmpty()){
            //2。 从栈弹出A
            head = stack.pop();
            //3。 打印A
            System.out.print(head.value + "->");
            //4。 如果A的右子树不空，则入栈
            if (head.right!=null){
                stack.push(head.right);
            }
            //5。 如果A的左子树不空，则入栈
            if (head.left!=null){
                stack.push(head.left);
            }
            //6。 如果栈不为空， 则继续第二步
        }
    }

非递归-中序遍历

public static void in_order(Node head){

        Stack<Node> stack = new Stack<>();
        if (head==null){
            return;
        }

        while (!stack.isEmpty() || head!=null ){
            //1.1。 如果当前节点不为空
            if (head!=null) {
                // 1.2。 当前节点入栈
                stack.push(head);
                // 1.3。继续往左走
                head = head.left;
            }
            // 1.4。 直到没有左节点了
            else {
                // 2.1。没有左节点后，出栈
                head = stack.pop();
                // 2.2。 打印
                System.out.print(head.value + " -> ");
                // 2.3。 找到他的右节点
                head = head.right;
                //2.4。 从1.1继续
            }
        }


    }

非递归-后续遍历

public static void pos_order(Node head){

        if (head==null){
            return;
        }
        Stack<Node> stack1 = new Stack<>(); // 临时栈
        Stack<Node> stack2 = new Stack<>(); // 收集栈

        //1。 头节点入临时栈
        stack1.add(head);
        while (!stack1.isEmpty()){
            //2。 弹出临时栈
            head = stack1.pop();
            //3。 弹出的节点A放入收集栈中
            stack2.push(head);
            //4。 A的左节点入临时栈
            if (head.left != null){
                stack1.push(head.left);
            }
            //4。 A的右节点入临时栈
            if (head.right != null){
                stack1.push(head.right);
            }
        }
        //5。 最后依次弹出收集栈的内容并打印
        while (!stack2.isEmpty()){
            head = stack2.pop();
            System.out.print( head.value + " -> ");
        }

    }

非递归-宽度优先遍历

public static void wide_order(Node head){

        if (head==null){
            return;
        }
        //1。 利用队列先进先出的性质
        Queue<Node> queue = new LinkedList<>();
        //2。 头节点放进去
        queue.add(head);
        while (!queue.isEmpty()){
            //3。 A出队列 即打印
            Node curr = queue.poll();
            System.out.print(curr.value + " -> ");
            //4。 A的左节点入队列
            if (curr.left!=null){
                queue.add(curr.left);
            }
            //5。 A的右节点入队列
            if (curr.right!=null){
                queue.add(curr.right);
            }

        }

    }