二叉树的前序遍历、中序遍历、后序遍历、层次遍历

package demo;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * @author pert
 * @date 2021年08月06日 11:02
 */
public class doubleTree {

    //    定义节点
    static class TreeNode{
        int key;
        TreeNode left;
//        nodeList.get(parentIndex).left=nodeList.get(parentIndex*2+1);
        TreeNode right;

        public TreeNode (int key) {
            left=null;
            right=null;
            this.key=key;
        }
    }

/*//    建立二叉树
    public static List<TreeNode> createTree(){
        int[]array={1,2,3,4,5,6,7,8,9};
        List<TreeNode> nodeList=new ArrayList<>();
        for (int nodeIndex=0;nodeIndex<array.length;nodeIndex++){
            nodeList.add(new TreeNode(array[nodeIndex]));
        }
        for (int parentIndex = 0; parentIndex < array.length / 2 - 1; parentIndex++) {
//            左孩子
            nodeList.get(parentIndex).left=nodeList.get(parentIndex*2+1);
//            右孩子
            nodeList.get(parentIndex).right=nodeList.get(parentIndex*2+2);
        }
//        最后一个父节点，可能没有右孩子的情况，单独处理
        int lastParentIndex=array.length/2-1;
//        左孩子
        nodeList.get(lastParentIndex).left=nodeList.get(lastParentIndex*2+1);
//        右孩子，如果长度为奇数则建立右孩子
        if(array.length%2==1){
            nodeList.get(lastParentIndex).right=nodeList.get(lastParentIndex*2+2);
        }
        return nodeList;
    }*/

    //    建立二叉树
    public static TreeNode createTree(){
        int[]array={1,2,3,4,5,6,7,8,9};
        List<TreeNode> nodeList=new ArrayList<>();
        for (int nodeIndex=0;nodeIndex<array.length;nodeIndex++){
            nodeList.add(new TreeNode(array[nodeIndex]));
        }
        for (int parentIndex = 0; parentIndex < array.length / 2 - 1; parentIndex++) {
//            左孩子
            nodeList.get(parentIndex).left=nodeList.get(parentIndex*2+1);
//            右孩子
            nodeList.get(parentIndex).right=nodeList.get(parentIndex*2+2);
        }
//        最后一个父节点，可能没有右孩子的情况，单独处理
        int lastParentIndex=array.length/2-1;
//        左孩子
        nodeList.get(lastParentIndex).left=nodeList.get(lastParentIndex*2+1);
//        右孩子，如果长度为奇数则建立右孩子
        if(array.length%2==1){
            nodeList.get(lastParentIndex).right=nodeList.get(lastParentIndex*2+2);
        }
        return nodeList.get(0);
    }


//    1.前序遍历，先访问根节点，然后前序遍历左子树，再前序遍历右子树。。。此处结果应该为1-2-4-8-9-5-3-6-7
//前序遍历,递归方式
//    先序遍历/前序遍历：根-左-右
    public static void preOderTraverse(TreeNode node)
        {
            if(node == null)
                return;
            System.out.print(node.key+ " ");
            preOderTraverse(node.left);
            preOderTraverse(node.right);
        }

//2.中序遍历，先中序遍历根节点的左子树，然后访问根节点最后中序遍历根节点的右子树。此处结果应该为8-4-9-2-5-1-6-3-7
    //中序遍历,递归方式   左-根-右
    public static void inOrderTraverse(TreeNode node){

        if(node == null)
            return;
        inOrderTraverse(node.left);
        System.out.print(node.key+" ");
        inOrderTraverse(node.right);

    }

//    3.后序遍历，从左到右后节点的方式访问左右字数，最后访问根节点，左右中的顺序。此处结果应该为,8-9-4-5-2-6-7-3-1
//后序遍历,递归方式   左-右-根          始终输出根节点！
    public static void postOrdeTraverse(TreeNode node){

        if(node == null)
            return;
        postOrdeTraverse(node.left);
        postOrdeTraverse(node.right);
        System.out.print(node.key+" ");

    }

//4.层序遍历，这个是最符合常规思维的遍历方式，从上往下，一层一层的从左往右遍历，此处结果为1-2-3-4-5-6-7-8-9
//层序遍历(一层一层的遍历)
    public static void LaywerTraverse(TreeNode node){

        if(node == null)
            return;

//        初始化一个链表节点队列：
        LinkedList<TreeNode> mList = new LinkedList<>();
        mList.add(node);
        TreeNode currentNode;//currentNode只有data和左右指针
        while (!mList.isEmpty()){
            currentNode = mList.poll();//队首元素出队；先进先出
//            poll是队列数据结构实现类的方法，从队首获取元素，同时获取的这个元素将从原队列删除；
//            pop是栈结构的实现类的方法，表示返回栈顶的元素，同时该元素从栈中删除，当栈中没有元素时，调用该方法会发生异常
            System.out.println(currentNode.key);
            if(currentNode.left != null){
                mList.add(currentNode.left);
            }
            if(currentNode.right != null){
                mList.add(currentNode.right);
            }
        }

    }

    public static void main(String[] args) {

        /*List<TreeNode> tree=createTree();
        inOrderTraverse(tree.get(0));*/

        TreeNode tree=createTree();
        System.out.println("中序遍历：");
        inOrderTraverse(tree);

        System.out.println('\n'+"层次遍历：");
        LaywerTraverse(tree);
    }
}