二叉树前序遍历&中序遍历&后序遍历&层序遍历（Java版）

二叉树前中后序遍历&层序遍历（Java版）

本篇整理二叉树的前中后序遍历以及层序遍历附加二叉树的封装
参考博文：
【 coder__666 、 youngogo 】
同样是coder，有些人代码就是规范，就是好看！！哈哈哈哈哈
一、前中后序遍历（DFS思想：递归或者栈）
先序遍历特点：第一个值是根节点
中序遍历特点：根节点左边都是左子树，右边都是右子树
三种遍历的非递归方法都是用栈来保存先前走过的路径，以便可以在访问完子树后,可以利用栈中的信息,回退到当前节点的父节点,进行下一步操作。

1. 前序遍历（根、左、右）ABDECF
1.1 递归法
递归的解决左右子树
1.2 借助栈的非递归解法
一路向左压栈并打印直到最左结点，然后从最底向上（出栈）遍历右子树（重复向左压栈和出栈的过程）
1.3 借助栈的迭代解法
从根节点开始，每出栈一个元素，就把右结点和左结点压栈，先右后左（因为出栈时需要先左后右），直到栈为空
2. 中序遍历（左、根、右）DBEAFC
2.1递归法（类似于前序遍历递归法）
2.2 借助栈的非递归解法
见程序注释
3.中序遍历（左、右、根）DEBFCA
3.1递归法（类似于前序遍历递归法）
3.2 借助双栈的非递归解法
利用栈回退时，并不知道是从左子树回退到根节点，还是从右子树回退到根节点，如果从左子树回退到根节点，此时就应该去访问右子树，而如果从右子树回退到根节点，此时就应该访问根节点。所以相比前序和后序，必须得在压栈时添加信息，以便在退栈时可以知道是从左子树返回，还是从右子树返回进而决定下一步的操作。
信息栈和结点栈的对应位置标记的是当前根结点的上一结点是从左(left)还是右孩子(right)返回的，所以每次从左子树返回去遍历右子树时，根结点先不要出栈，并且要把标志变成right(出栈left再入栈right)；从右子树返回时就可以把当前根结点和标志位都出栈了
3.3借助单栈和两个结点标记的非递归解法
同3.2，需要区分上一个遍历过的结点是左结点还是右结点，这里用当前结点和上一个结点两个变量来标记，解释见代码注释
二、层序遍历（BFS思想：队列） ABCDEF
从上往下从左往右一层一层的遍历
层次遍历的步骤是：
1.对于不为空的结点，先把该结点加入到队列中
2.从队中拿出结点，如果该结点的左右结点不为空，就分别把左右结点加入到队列中
3.重复以上操作直到队列为空

---

Java代码（对二叉树类进行了封装）
1. 二叉树结点类 TreeNode.class

/**
 * @ClassName TreeNode
 * @Discription 二叉树节点类
 * @Author lemon
 * @Date 2020/4/7 16:20
 **/
public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }

    TreeNode(int x,TreeNode left,TreeNode right) {
        this.val = x;
        this.left = left;
        this.right = right;
    }
}

2. 二叉树接口（具有哪些功能）BinaryTree.class

/**
 * @ClassName BinaryTree
 * @Discription 二叉树接口
 * @Author lemon
 * @Date 2020/4/7 15:24
 **/
public interface BinaryTree {

    /**
     * @return 二叉树元素总个数
     */
    public int size();

    /**
     * @return 二叉树是否为空
     */
    public boolean isEmpty();

    /**
     * @return 二叉树的高度（层数）
     */
    public int getHeight();

    /**
     *以数组形式生成一颗完全二叉树
     *@param n 二叉树元素个数
     */
    public static TreeNode constructBinaryTree(int n) {
        /**以数组形式生成一颗完全二叉树*/
        TreeNode[] tree = new TreeNode[n];
        for (int i = 0; i < n; i++) {
            tree[i] = new TreeNode(i);
        }
        for (int i = 0; i <= (n / 2 - 1); i++) {
            tree[i].left = tree[2 * i + 1];
            if ((2 * i + 1) < n - 1) {
                tree[i].right = tree[2 * i + 2];
            }
        }
        return tree[0];
    }

    /**
     * 前序遍历递归算法；打印到控制台
     */
    public void preOrderRecursion();

    /**
     * 前序遍历非递归算法（借助栈）；打印到控制台
     */
    public void preOrderNonRecursion();

    /**
     * 前序遍历迭代算法；打印到控制台
     */
    public void preOrderIterate();

    /**
     * 中序遍历递归算法；打印到控制台
     */
    public void midOrderRecursion();

    /**
     * 中序遍历非递归（借助栈）；打印到控制台
     */
    public void midOrderNonRecursion();

    /**
     * 后序遍历递归算法；打印到控制台
     */
    public void postOrderRecursion();

    /**
     * 后序遍历非递归（借助双栈）；打印到控制台
     */
    public void postOrderNonRecursion();

    /**
     * 后序遍历迭代法（借助单栈和标志变量）；打印到控制台
     */
    public void postOrderIterate();

    /**
     * 层序遍历（利用队列）
     */
    public void levelOrder();

}

3. 二叉树实现类 BinaryTreeTraversal.class

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

/**
 * @ClassName BinaryTreeTraversal
 * @Discription 二叉树的前中后序遍历
 * @Author lemon
 * @Date 2020/4/6 15:24
 **/


public class BinaryTreeTraversal implements BinaryTree{

    /**创建此类的根结点*/
    private TreeNode myRoot;

    public BinaryTreeTraversal(TreeNode root){
        super();
        myRoot = root;
    }

public BinaryTreeTraversal(){
        super();
    }

 public static void main(String[] args) {
        TreeNode myTree = BinaryTree.constructBinaryTree(10);
        BinaryTreeTraversal binaryTreeTraversal = new BinaryTreeTraversal(myTree);
        System.out.println("树的高度:"+binaryTreeTraversal.getHeight());
        binaryTreeTraversal.preOrderRecursion();
        binaryTreeTraversal.preOrderNonRecursion();
        binaryTreeTraversal.preOrderIterate();
        binaryTreeTraversal.midOrderRecursion();
        binaryTreeTraversal.midOrderNonRecursion();
        binaryTreeTraversal.postOrderRecursion();
        binaryTreeTraversal.postOrderNonRecursion();
        binaryTreeTraversal.postOrderIterate();
        binaryTreeTraversal.levelOrder();
    }

    @Override
    public int size() {
        return this.size(myRoot);
    }
    public int size(TreeNode root){
        if(root == null){
            return 0;
        }
        else {
            //递归求得左右子树的元素个数，然后加上根结点
            int left = size(root.left);
            int right = size(root.right);
            return left+right+1;
        }
    }

    @Override
    public boolean isEmpty() {
        return myRoot == null;
    }

    @Override
    public int getHeight() {
        return this.getHeight(myRoot);
    }

    public int getHeight(TreeNode root){
        if(root == null){
            return 0;
        }
        else {
            //递归求得左右子树的高度，取较高的那个加上根结点
            int left = getHeight(root.left);
            int right = getHeight(root.right);
            return left>right ? left+1:right+1;
        }
    }

    //进一步封装遍历方法

    @Override
    public void preOrderRecursion() {
        if(myRoot != null){
            System.out.println("前序遍历递归法：");
            preOrderRecursion(myRoot);
            System.out.println();
        }
        else {
            System.out.println("此二叉树为空");
        }
    }

    public void preOrderRecursion(TreeNode root) {
        if (root == null) {
            return;
        }
        System.out.print(root.val+" ");
        preOrderRecursion(root.left);
        preOrderRecursion(root.right);
    }

    @Override
    public void preOrderNonRecursion() {
        if(myRoot != null){
            System.out.println("前序遍历非递归法（借助栈）：");
            preOrderNonRecursion(myRoot);
            System.out.println();
        }
        else {
            System.out.println("此二叉树为空");
        }
    }

    public void preOrderNonRecursion(TreeNode root){

        if (root == null) {
            return;
        }

        Stack<TreeNode> toolStack = new Stack<>();

        while (root != null || !toolStack.empty()) {
            //一路压栈并打印，直到最左结点
            while (root != null) {
                System.out.print(root.val+" ");
                toolStack.push(root);
                root = root.left;
            }
            //从下往上依次遍历右子树
            if (!toolStack.empty()) {
                root = toolStack.pop().right;
            }
        }
    }

    @Override
    public void preOrderIterate() {
        if(myRoot != null){
            System.out.println("前序遍历迭代法（借助栈）：");
            preOrderIterate(myRoot);
            System.out.println();
        }
        else {
            System.out.println("此二叉树为空");
        }
    }

    public void preOrderIterate(TreeNode root) {

        if(root == null){
            return;
        }
        Stack<TreeNode> toolStack = new Stack<>();
        toolStack.push(root);
        //从根节点开始，每出栈一个元素，就把右结点和左结点压栈，先右后左（因为出栈时需要先左后右），直到栈为空
        while (!toolStack.empty()) {
            root = toolStack.pop();
            System.out.print(root.val+" ");
            if(root.right != null){
                toolStack.push(root.right);
            }
            if(root.left != null){
                toolStack.push(root.left);
            }
        }
    }

    @Override
    public void midOrderRecursion() {
        if(myRoot != null){
            System.out.println("中序遍历递归法：");
            midOrderRecursion(myRoot);
            System.out.println();
        }
        else {
            System.out.println("此二叉树为空");
        }
    }

    public void midOrderRecursion(TreeNode root) {
        if (root == null) {
            return;
        }
        midOrderRecursion(root.left);
        System.out.print(root.val+" ");
        midOrderRecursion(root.right);
    }

    @Override
    public void midOrderNonRecursion() {
        if(myRoot != null){
            System.out.println("中序遍历非递归法（借助栈）：");
            midOrderNonRecursion(myRoot);
            System.out.println();
        }
        else {
            System.out.println("此二叉树为空");
        }
    }

    public void midOrderNonRecursion(TreeNode root) {

        if (root == null) {
            return;
        }

        Stack<TreeNode> toolStack = new Stack<>();
        while (root != null || !toolStack.empty()) {

            //一路压栈，直到最左结点
            while (root != null) {
                toolStack.push(root);
                root = root.left;
            }
            //先打印左结点,然后出栈根结点，然后从下往上用同样的方法操作右子树
            if (!toolStack.empty()) {
                root = toolStack.pop();
                System.out.print(root.val+" ");
                //最左结点的右结点是null，所以打印完左结点之后会出栈并打印根结点，再转向右结点
                root = root.right;
            }
        }
    }

    @Override
    public void postOrderRecursion() {
        if(myRoot != null){
            System.out.println("后序遍历递归法：");
            postOrderRecursion(myRoot);
            System.out.println();
        }
        else {
            System.out.println("此二叉树为空");
        }
    }

    public void postOrderRecursion(TreeNode root) {
        if (root == null) {
            return;
        }
        postOrderRecursion(root.left);
        postOrderRecursion(root.right);
        System.out.print(root.val+" ");
    }

    @Override
    public void postOrderNonRecursion() {
        if(myRoot != null){
            System.out.println("后序遍历非递归法（借助栈）：");
            postOrderNonRecursion(myRoot);
            System.out.println();
        }
        else {
            System.out.println("此二叉树为空");
        }
    }

    public void postOrderNonRecursion(TreeNode root) {

        if (root == null) {
            return;
        }

        //标记从左子树还是右子树返回
        int left = 1;
        int right = 2;

        //存放标志的栈和存放结点的栈
        Stack<Integer> signStack = new Stack<>();
        Stack<TreeNode> toolStack = new Stack<>();
        while (root != null || !toolStack.empty()) {
            //一路压栈，直到最左结点
            while (root != null) {
                toolStack.push(root);
                signStack.push(left);
                root = root.left;
            }

            //从条件来看，后序遍历这里是能保证底下的条件判断之前，栈一定是不为空的，所以不用再写判空了

            //从左子树返回：根结点先不要出栈，标志位改为right，并转向右子树
            if(signStack.peek() == left){
                signStack.pop();
                signStack.push(right);
                root = toolStack.peek().right;
            }
            //从右子树返回：根结点出栈，标志位也出栈
            else if(signStack.peek() == right){
                signStack.pop();
                System.out.print(toolStack.pop().val+" ");
            }
        }
    }

    @Override
    public void postOrderIterate() {
        if(myRoot != null){
            System.out.println("后序遍历迭代法（借助栈）：");
            postOrderIterate(myRoot);
            System.out.println();
        }
        else {
            System.out.println("此二叉树为空");
        }
    }

    public void postOrderIterate(TreeNode root) {

        if (root == null) {
            return;
        }

        //cur为当前结点，last为上一个遍历过的结点
        TreeNode cur = null;
        TreeNode last = null;

        //存放结点的栈
        Stack<TreeNode> toolStack = new Stack<>();
        while (root != null || !toolStack.empty()) {
            //一路压栈，直到最左结点
            while (root != null) {
                toolStack.push(root);
                root = root.left;
            }

            //从条件来看，后序遍历这里是能保证底下的条件判断之前，栈一定是不为空的，所以不用再写判空了

            cur = toolStack.peek();
            //从右子树返回：当前结点的右儿子为上一个遍历过的结点或者为null（叶节点），此时应该把根结点出栈并打印并更新last（root不要动）
            if( cur.right == null || cur.right == last){
                last = toolStack.pop();
                System.out.print(last.val+" ");
            }
            //从左子树返回：转向当前根结点的右子树
            else{
                //根结点还不能出栈
                root = cur.right;
            }
        }
    }

    @Override
    public void levelOrder() {
        if(myRoot != null){
            System.out.println("层序遍历（借助队列）：");
            levelOrder(myRoot);
            System.out.println();
        }
        else {
            System.out.println("此二叉树为空");
        }
    }

    public void levelOrder(TreeNode root){
        if(root == null){
            return;
        }
        Queue<TreeNode> toolQueue = new LinkedList<>();
        toolQueue.offer(root);
        while(!toolQueue.isEmpty()){
            //每出队一个结点就把左右孩子放进去排队（左右孩子不为空时）
            root = toolQueue.poll();
            System.out.print(root.val+" ");
            if(root.left != null){
                toolQueue.offer(root.left);
            }
            if(root.right != null){
                toolQueue.offer(root.right);
            }
        }
    }
   
}