java-二叉树遍历

1，完全二叉树-建树，先建简单的树，用简单的树学习各种遍历

 2，根据先中序建树，根据中后序建树

//先简单建树-按完全二叉树节点插入顺序建树，即层序遍历。

/**二叉树：每个节点最多两个孩子节点（计划生育-最多生二胎）；
 * 完全二叉树（遏制人口老龄化：必须生两胎，否则不准后代传宗接代）：
 *            根节点（爷爷）先生，生不满两胎接着生，爷爷生完，老大（左爸爸）生，
 *            生不满二胎，爷爷的小儿子不准生，。。。依次类推。
* */

/**按层间遍历顺序加入节点
 层序遍历用队列，根节点入队，
 执行循环，当队列不为空{对首X出队，若X左孩子非空，入队，右孩子非空入队}
 */

/**层序遍历（用队列先进先出性能实①现先访问根节点（第一层）
        ②再依次访问根节点的左右孩子节点（第二层）
        ③再依次访问根节点左右孩子节点的左右孙子节点(第三层)，
        ④.....
 */

/**？
 * 功能
 * ①，建树--体会完全二叉树，添加节点过程（先建简单的，主要还是体会各种遍历）
 * ②，4种遍历，7种方法，前、中、后序递归遍历，前、中、后非递归遍历，层序遍历。
 * ③，删树，
 * ④，求树高
 * ⑤，树状打印
 * ⑥，
 */

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

public class Easy_BiTree {
    //内部Node类
    public class Node {
        private int data=Integer.MAX_VALUE;
        private Node lchild=null;
        private Node rchild=null;

        public Node(){}
        public Node(int data){
            this.data=data;
        }
    }

    private Node root=null;
    private int size=0;
    public Easy_BiTree(){}

    //添加节点
    public void addNode(Node root,int data){
        //根节点
        if(size==0){
            this.root=new Node(data);
            size++;
        }else{
            Node newNode=new Node(data);

            // 添加节点用层序遍历方法目的不是为了遍历每一个节点,而是按层次顺序找到第一个孩子不满（没生二胎）的节点
            // 当遇到孩子节点没满的Node,添加节点-退出；
            Queue<Node> queue=new LinkedList<>();
            queue.add(root);
            while(!queue.isEmpty()){
                Node curroot=queue.poll();
                if(curroot.lchild!=null)
                    queue.add(curroot.lchild);
                else{
                    curroot.lchild=newNode;
                    size++;
                    return;
                }
                if(curroot.rchild!=null)
                    queue.add(curroot.rchild);
                else{
                    curroot.rchild=newNode;
                    size++;
                    return;
                }
            }
        }
    }

    //遍历-前序非递归，

    /**
     * ①顺着根节点的左孩子一路到底，一边输出一边入栈，
     * ②到底后，判断栈顶有没有右子树，有以右子节点为根节点重复①，没有则出栈，
     */
    public void preOrder(Node root){
        if(size==0)
            System.out.println("树空无遍历");
        else{
            System.out.print("树前序非递归： ");
            Stack<Node> stack=new Stack<>();
            while(root!=null||!stack.isEmpty()){
                while(root!=null){
                    System.out.print(root.data+" ");
                    stack.add(root);
                    root=root.lchild;
                }
                if(!stack.isEmpty()){
                    root=stack.pop();
                    root=root.rchild;
                }
            }
            System.out.println();
        }
    }
    //遍历-中序非递归，
    public void inOrder(Node root){
        if(size==0)
            System.out.println("树空，无遍历");
        else {
            System.out.print("树中序非递归： ");
            Stack<Node> stack=new Stack<>();
            while(root!=null||!stack.isEmpty()){
                while(root!=null){
                    stack.add(root);
                    root=root.lchild;
                }
                if(!stack.isEmpty()){
                    root=stack.pop();
                    System.out.print(root.data+" ");
                    root=root.rchild;
                }
            }
            System.out.println();
        }
    }
    //遍历-后序非递归，
    /**
     *①顺着根节点的左孩子一路到底，入栈，
     * ②到底后，判断栈顶有没有右子树，没有出栈，输出
     * ③有右子节点，右子节点遍历之前不能出栈，preNode,即标识右子节点有没有遍历，
     *          以右子节点为根节点重复①，②③
     */
    public void postOrder(Node root){
        if(size==0)
            System.out.println("树空，无遍历");
        else {
            System.out.print("树后序非递归： ");
            Stack<Node> stack=new Stack<>();
            while(root!=null||!stack.isEmpty()){
                while(root!=null){
                    stack.push(root);
                    root=root.lchild;
                }
                boolean tag=true;
                Node preNode=null;
                while(!stack.isEmpty()&&tag==true){
                    root=stack.peek();
                    if(root.rchild==preNode){
                        root=stack.pop();
                        System.out.print(root.data+" ");
                        if(stack.isEmpty()){
                            System.out.println();
                            return;
                        }
                        else
                            preNode=root;
                    }else{
                        root=root.rchild;
                        tag=false;
                    }
                }
            }
            System.out.println();
        }
    }

    /**
     * 额。。递归写起来是很简单，我也说不好原理，233
     */
    //遍历-前序递归，
    public void preOrderRec(Node root){
        if(root==null)
            return;
        else {
            System.out.print(root.data+" ");
            preOrderRec(root.lchild);
            preOrderRec(root.rchild);
        }
    }
    //遍历-中序递归，
    public void inOrderRec(Node root){
        if(root==null)
            return;
        else{
            inOrderRec(root.lchild);
            System.out.print(root.data+" ");
            inOrderRec(root.rchild);
        }
    }
    //遍历-后序递归，
    public void postOrderRec(Node root){
        if(root==null)
            return;
        else{
            postOrderRec(root.lchild);
            postOrderRec(root.rchild);
            System.out.print(root.data+" ");
        }
    }



    //遍历，-层间遍历
    public void levelOrder(Node root){
        if(this.size==0)
            System.out.println("空树，无法遍历");
        else{
            System.out.println("树层间遍历：");
            Queue<Node> queue=new LinkedList<>();
            queue.add(root);
            while(!queue.isEmpty()){
                Node curroot=queue.poll();
                System.out.print(curroot.data+" ");
                if(curroot.lchild!=null)
                    queue.add(curroot.lchild);
                if(curroot.rchild!=null)
                    queue.add(curroot.rchild);
            }
            System.out.println();
        }
    }

    //删树
    //java有内存回收机制，只要把根节点状态，换成空树根节点状态即可；
    //C++也是类似遍历一遍，把遍历到的每一个节点free;

    //呃。。。。我猜的，哈哈哈哈哈哈哈哈
    public void deleteTree(){
        this.root=null;
        size=0;
    }

    /**
     * 树高-递归和非递归方法
     *     完全二叉树，节点和高有方程，log(size)向下取整+1
     *     这里用非特殊二叉树求树高，
     */

    //转载：https://blog.csdn.net/shijie97/article/details/79775399
    /**非递归-队列，
     *   根节点入队，出队，添加第二层，添加完后记录队size(0/1/2)，然后将（0/1/2）个出队，将他们的孩子入队，记录每一层
     *   孩子数，遍历完，即可知道层数
     */
    public int treeHeight(Node root){
        if(root==null)
            return 0;
        else if(size==1)
            return 1;
        else{
            Queue<Node> queue=new LinkedList<>();
            queue.add(root);
            int height=0;
            //记录每层孩子个数,root入队长为1
            int len=1;
            while(!queue.isEmpty()){
                int length=0;
                for(int i=0;i<len;i++){
                    Node curroot=queue.poll();
                    if(curroot.lchild!=null){
                        queue.add(curroot.lchild);
                        length++;
                    }
                    if(curroot.rchild!=null){
                        queue.add(curroot.rchild);
                        length++;
                    }
                }
                len=length;
                height++;
            }
            return height;
        }
    }
    //递归
    public int treeHeightRec(Node root){
        if(root==null)
            return 0;
        else{
            int a =treeHeightRec(root.lchild);
            int b = treeHeightRec(root.rchild);
            return (a>b)?(a+1):(b+1);
        }
    }

    //树状打印
    /**
     * 思路：先确定树高h-最后一层2^(h-1)个数，好知道根节点放在哪里（预留空间保证根再中间）
     * 设每个data三位数=space,元素之间空三位数，每行 (2^H+1)*3 个“ ”
     * _数_数_数_数_数_   每层2^(h-1)个数，2^(h-1)+1个space,最后一行长2^h+1个space
     *
     * 当层数多的时候稍乱，2333不想弄了，
     */
    public void printTree(Node root){
        int H=treeHeight(root);
        int h=H;
        //System.out.println("树高："+H);
        if(H==0)
            System.out.println("树空,无打印");
        else{
            System.out.println("打印树：");
            Queue<Node> queue=new LinkedList<>();
            queue.add(root);
            int height=1;
            //记录每层孩子个数
            int len=1;
            while(h>0){
                int length=0;
                String space="";
                for(int i=0;i<(((Math.pow(2,H)+1)*3)/(Math.pow(2,height)+1));i++)
                    space+=" ";
                for(int i=0;i<len;i++){
                    Node curroot=queue.poll();
                    if(curroot.data==Integer.MAX_VALUE){
                        System.out.print(space);
                    }else
                        System.out.print(space+curroot.data);

                    if(curroot.lchild!=null){
                        queue.add(curroot.lchild);
                    }
                    else
                        queue.add(new Node());
                    length++;
                    if(curroot.rchild!=null){
                        queue.add(curroot.rchild);
                    }
                    else
                        queue.add(new Node());
                    length++;
                }
                System.out.println();
                System.out.println();
                len=length;
                height++;
                h--;
            }
            System.out.println();
        }
    }


    /**
     *
     * 根据先序和中序创建二叉树
     *  转载：https://www.cnblogs.com/tuyang1129/p/11647443.html
     *  ①先序的第一个元素为根节点，②找出这个根节点在中序中的位置x,xx左边是根节点的左子树，右边是右子树
     *  ③递归建树
     *
     */

    public int getIndex(int data,int[] array){
        int num =Integer.MAX_VALUE;
        for(int i=0;i<array.length;i++){
            if(array[i]==data)
                num=i;
        }
        return num;
    }

    public Node preIn_BiTree(int[] pre,int[] in){
        if(pre.length==0){
            return null;
        }else if(pre.length==1){
            return new Node(pre[0]);
        }
        Node root=new Node(pre[0]);

        int index=getIndex(pre[0],in);

        //左子树
        int[] preleft= Arrays.copyOfRange(pre,1,index+1);
        int[] inleft=Arrays.copyOfRange(in,0,index);
        root.lchild=preIn_BiTree(preleft,inleft);

        //右子树
        int[] preright=Arrays.copyOfRange(pre,index+1,pre.length);
        int[] inright=Arrays.copyOfRange(in,index+1,in.length);
        root.rchild=preIn_BiTree(preright,inright);

        return root;

    }

    /**
     * 根据中序-后续
     * ①后序的第一个元素为根节点，②找出这个根节点在中序中的位置x,x左边是根节点的左子树，右边是右子树
     *  ③递归建树
     */
     public Node inPost_BiTree(int[] in,int[] post){
         if(in.length==0){
             return null;
         }else if(in.length==1){
             return new Node(in[0]);
         }
         Node root=new Node(post[post.length-1]);
         int index=getIndex(post[post.length-1],in);

         //左子树
         int[] postleft= Arrays.copyOfRange(post,0,index);
         int[] inleft=Arrays.copyOfRange(in,0,index);
         root.lchild=inPost_BiTree(inleft,postleft);

         //右子树
         int[] postright=Arrays.copyOfRange(post,index,post.length-1);
         int[] inright=Arrays.copyOfRange(in,index+1,in.length);
         root.rchild=inPost_BiTree(inright,postright);

         return root;

     }




    public static void main(String args[]) {
        /**
         * 完全二叉树的建立，与二叉树的遍历
         */
        Easy_BiTree t=new Easy_BiTree();
        t.addNode(t.root,1);
        t.addNode(t.root,2);
        t.addNode(t.root,3);
        t.addNode(t.root,4);
        t.addNode(t.root,5);
        t.addNode(t.root,6);
        t.addNode(t.root,7);
        t.addNode(t.root,8);
        t.addNode(t.root,9);
        t.addNode(t.root,10);
        t.addNode(t.root,11);
        t.addNode(t.root,12);
        t.addNode(t.root,13);
        t.addNode(t.root,14);
        t.addNode(t.root,15);
        t.addNode(t.root,16);
        t.addNode(t.root,17);
        t.addNode(t.root,18);
        t.addNode(t.root,19);
        t.addNode(t.root,20);
        t.addNode(t.root,21);

        t.levelOrder(t.root);
        System.out.println("非递归求树高： "+t.treeHeight(t.root));
        System.out.println("递归求树高： "+t.treeHeightRec(t.root));

        t.printTree(t.root);

        t.preOrder(t.root);
        t.inOrder(t.root);
        t.postOrder(t.root);

        System.out.print("树前序递归遍历： ");
        t.preOrderRec(t.root);
        System.out.println();
        System.out.print("树中序递归遍历： ");
        t.inOrderRec(t.root);
        System.out.println();
        System.out.print("树后序递归遍历： ");
        t.postOrderRec(t.root);
        System.out.println();

        t.deleteTree();
        System.out.println("非递归求树高： "+t.treeHeight(t.root));


        /**
         *  其他建树方法
         */
        int[] pre={1,2,4,7,3,5,6};
        int[] in={2,7,4,1,5,3,6};
        int[] post={7,4,2,5,6,3,1};

        int[] pre1={1,2,3,4,5,6,7};
        int[] in1={2,4,6,7,5,3,1};
        int[] post1={7,6,5,4,3,2,1};


        System.out.println("pre={1,2,4,7,3,5,6}");
        System.out.println("in={2,7,4,1,5,3,6}");
        Easy_BiTree t2=new Easy_BiTree();
        t2.root=t2.preIn_BiTree(pre,in);
        t2.printTree(t2.root);

        System.out.println("pre1={1,2,3,4,5,6,7}");
        System.out.println("in1={2,4,6,7,5,3,1}");
        Easy_BiTree t3=new Easy_BiTree();
        t3.root=t3.preIn_BiTree(pre1,in1);
        t3.printTree(t3.root);

        System.out.println("in={2,7,4,1,5,3,6}");
        System.out.println("post={7,4,2,5,6,3,1}");
        Easy_BiTree t4=new Easy_BiTree();
        t4.root=t4.inPost_BiTree(in,post);
        t4.printTree(t4.root);

        System.out.println("in1={2,7,4,1,5,3,6}");
        System.out.println("post1={7,4,2,5,6,3,1}");
        Easy_BiTree t5=new Easy_BiTree();
        t5.root=t5.inPost_BiTree(in1,post1);
        t5.printTree(t5.root);

    }
}