树的前、中、后、层次遍历

package com.yuan;

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

/**
 * @author QLBF 树的前中后遍历
 * @version 1.0
 * @date 2021/5/24 12:17
 */
class TreeNode{
    String val;
    TreeNode left;
    TreeNode right;

    public TreeNode(String val) {
        this.val = val;
    }

}
public class TreeDemo {
    //前序遍历(递归方式)
    public static void preorder(TreeNode treeNode){
        if (treeNode==null){
            return;
        }
        System.out.print(treeNode.val+" ");
        if (treeNode.left!=null){
            preorder(treeNode.left);
        }
        if (treeNode.right!=null){
            preorder(treeNode.right);
        }
    }

    //前序遍历（非递归方式）
    //用栈结构，把遍历到的节点压进栈，没子节点时再出栈
    public static void preorder_not(TreeNode treeNode){
        Stack<TreeNode> stack=new Stack<>();
        //两个条件缺一不可
        while (treeNode !=null || !stack.isEmpty()){
            while (treeNode !=null){
                System.out.println(treeNode.val);
                stack.push(treeNode);
                treeNode=treeNode.left;
            }
            if (!stack.isEmpty()){
                treeNode=stack.pop();
                treeNode=treeNode.right;
            }
        }
    }

    //中序遍历
    public static void inorder(TreeNode treeNode){
        if (treeNode==null){
            return;
        }
        if (treeNode.left!=null){
            inorder(treeNode.left);
        }
        System.out.print(treeNode.val+" ");
        if (treeNode.right!=null){
            inorder(treeNode.right);
        }
    }

    /*
    先序、中序的非递归算法共同之处：用栈来保存先前走过的路径，
    以便可以在访问完子树后
    ,可以利用栈中的信息,回退到当前节点的双亲节点,进行下一步操作。
    */
    //中序遍历（非递归）
    //看这个也行：https://leetcode-cn.com/problems/binary-search-tree-iterator/
    public static void inorder_not(TreeNode treeNode){
        Stack<TreeNode> stack=new Stack<>();
        while (treeNode !=null || !stack.isEmpty()){
            while (treeNode !=null){
                stack.push(treeNode);
                treeNode=treeNode.left;
            }
            if (!stack.isEmpty()){
                treeNode=stack.pop();
                System.out.println(treeNode.val);
                treeNode=treeNode.right;
            }
        }
    }

    //后序遍历（非递归） 常规遍历左右根，和前序、中序方法一类似。
    //参考：[https://blog.csdn.net/weixin_44404255/article/details/104517916](https://blog.csdn.net/weixin_44404255/article/details/104517916)

    public static void postOrder_not(TreeNode root){
        Stack<TreeNode> stack=new Stack<>();
        TreeNode prev=null; //prev记录的是上次访问打印的节点
        while (root!=null || !stack.isEmpty()){
            while (root!=null){
                //访问左子树
                stack.push(root);
                root=root.left;
            }
            //判断栈顶元素(根)
            root=stack.peek();
            //1.如果此时的根的右子树为空root.right == null
            //2.如果此时的根的右子树已经访问过了root.right == prev(prev记录的是上次访问打印的节点)
            if (root.right==null || root.right==prev){
                //打印根节点，并出栈，将打印过的节点从栈中删除
                stack.pop();
                System.out.print(root.val+" ");
                //记录prev，表示以当前prev为根的子树已经访问过了
                prev=root;
                //root置null就不会再次访问以root为根节点的左右子树，这里的root既然已经打印，说明它的左右子树早已访问完毕
                root=null;
            }else {
                //访问右子树
                root=root.right;
            }
        }
    }
    //后序遍历（递归）
    public static void postorder(TreeNode treeNode){
        if (treeNode==null){
            return;
        }
        if (treeNode.left!=null){
            postorder(treeNode.left);
        }
        if (treeNode.right!=null){
            postorder(treeNode.right);
        }
        System.out.print(treeNode.val+" ");
    }

    //层次遍历：借助一个队列的实现，先将根节点入队，开启循环，队空的时候退出，循环的内容为：
    //    开始只要根结点入队，如果队列非空，再把它弹出，再把它的左右子树入队
    public static ArrayList<String> printFromTopToButtom(TreeNode rootNode){
        ArrayList<String> list=new ArrayList<>();//存放结果
        Queue<TreeNode> queue=new LinkedList<>(); //辅助队列

        if (rootNode!=null){
            //根节点入队
            queue.offer(rootNode);
        }
        //队列不为空，执行循环
        while (!queue.isEmpty()){
            TreeNode node=queue.poll();
            list.add(node.val);

            //如果有左节点，就把左节点加入
            if (node.left!=null){
                queue.offer(node.left);
            }
            //如果有右节点，就把右节点加入
            if (node.right!=null){
                queue.offer(node.right);
            }
        }
        return list;
    }
    public static void main(String[] args) {
        TreeNode t1=new TreeNode("A");
        TreeNode t2=new TreeNode("B");
        t1.left=t2;
        TreeNode t3=new TreeNode("C");
        t1.right=t3;
        TreeNode t4=new TreeNode("D");
        t2.right=t4;
        TreeNode t5=new TreeNode("E");
        t3.left=t5;
/*
        System.out.print("前序遍历（递归）:");
        preorder(t1);
        System.out.println();

        System.out.print("前序遍历（非递归）:");
        preorder_not(t1);
        System.out.println();

        System.out.print("中序遍历(递归):");
        inorder(t1);
        System.out.println();

        System.out.print("中序遍历(非递归):");
        inorder_not(t1);
        System.out.println();
*/
        /*
        System.out.print("后序遍历:");
        postorder(t1);
        System.out.println();

        System.out.print("层次遍历:");
        ArrayList<String> list = printFromTopToButtom(t1);
        System.out.println(list);
        */
    }
}