注释全在代码里面了。

先序遍历

对应leetcode题目：LC144

/**
 *
 * 遍历顺序:头左右
 *
 * @author zrulin
 * @create 2022-03-15 21:05
 */
public class 先序遍历 {

//递归实现：
    public static void preTraversal(Node head){
        if(head == null){
            return;
        }
        System.out.print(head.value+" ");
        preTraversal(head.left);
        preTraversal(head.right);
    }

    //非递归实现先序遍历：
    //思想：递归就是系统帮你压栈，自己压栈就好了。弹出的顺序是头左右
    /**
     * 步骤：
     * 1、头节点入栈
     * 2、每次从栈中弹出一个节点var
     * 3、处理（打印）var
     * 4、先把var的右节点压入栈（如果有的话），在把var左节点压入栈（如果有的话）<!--如果想要头右左遍历的话，改一下这个步骤的先后顺序就好了-->
     * 5、执行步骤二（周而复始）
     */
    public static void preTraversalStack(Node head){
        System.out.print("pre-order: ");
        if(head != null){
            Stack<Node> stack = new Stack<>();
            stack.add(head);
            while (!stack.isEmpty()){
                head = stack.pop();
                System.out.print(head.value + " ");
                if(head.right != null) stack.push(head.right);
                if(head.left != null) stack.push(head.left);
            }
        }
        System.out.println();
    }
}

中序遍历

对应leetcode题目：LC94

/**
 *
 * 遍历顺序：左头右
 *
 * @author zrulin
 * @create 2022-03-15 21:05
 */
public class 中序遍历 {

    public static void inTraversal(Node head){
        if(head == null) return;
        inTraversal(head.left);
        System.out.println(head.value + " ");
        inTraversal(head.right);
    }

    //非递归实现中序遍历
    //思想：先逮住一棵树，把他的左边界全部压入栈，在弹出每一个节点的过程中，打印并且让他的右树也这么干。
    /**
     *步骤：
     * 1、先把以head为头节点的树的左边界全部压入栈
     * 2、弹出一个节点var并处理（打印）这个节点
     * 2、如果var有右节点，那么执行步骤1，如果没有则执行步骤2
     */
    public static void inTraversalStack(Node head){
        System.out.print("in-order: ");
        if(head != null){
            Stack<Node> stack = new Stack<>();
            while (!stack.isEmpty() || head != null){
                if(head != null){
                    stack.push(head);
                    head = head.left;
                }else {
                    head = stack.pop();
                    System.out.print(head.value + " ");
                    head = head.right;
                }
            }
        }
    }
}

后序遍历

对应leetcode题目：LC145

/**
 *
 * 遍历顺序：左右头
 *
 * @author zrulin
 * @create 2022-03-15 21:05
 */
public class 后序遍历 {

    public static void posTraversal(Node head){
        if(head == null) return;
        posTraversal(head.left);
        posTraversal(head.right);
        System.out.println(head.value + " ");
    }

    //非递归实现后序遍历（理解不了的话再看看先序遍历，其实是在先序遍历的基础上进行改动的）
    //思想：递归就是系统帮你压栈，自己压栈就好了,弹出的顺序是头右左，但是该打印的时候不打印，而是压栈，从收集栈里面出来的顺序就是左右头了。
    /**
     *步骤：
     * 1、头节点入栈
     * 2、每次从栈中弹出一个节点var
     * 3、var放入收集栈。
     * 4、先把var的右节点压入栈（如果有的话），在把var左节点压入栈（如果有的话）
     * 5、执行步骤二（周而复始）
     */
    public static void posTraversalStack(Node head){
        System.out.print("pos-order: ");
        if(head != null){
            Stack<Node> stack1 = new Stack<>();
            Stack<Node> stack2 = new Stack<>();//收集栈

            stack1.push(head);
            while(!stack1.isEmpty()){
                head = stack1.pop();
                stack2.push(head);
                if(head.left != null) stack1.push(head.left);
                if(head.right != null) stack1.push(head.right);
            }
            while (!stack2.isEmpty()){
                System.out.print(stack2.pop().value + " ");
            }
        }
        System.out.println();
    }
}

宽度优先遍历

/**
 * 二叉树的深度优先遍历就是二叉树的先序遍历
 *
 * @author zrulin
 * @create 2022-03-15 21:05
 */
public class 宽度优先遍历 {

    //宽度优先遍历用队列
    public static void widthTraversal(Node head){
        System.out.print("width-order: ");
        if(head != null){
            Queue<Node> queue = new LinkedList<>();
            queue.add(head);
            while(!queue.isEmpty()){
                head = queue.poll();
                System.out.println(head.value + "");
                if(head.left != null) queue.add(head.left);
                if(head.right != null) queue.add(head.right);
            }
        }
        System.out.println();
    }
}

这次分享可以说是一个笔记，可以去看视频哦：左神讲算法