java 有序二叉树插入代码与四种遍历

        有序二叉树，顾名思义他是有序的，该树的每一个结点的左节点都小于该节点，所有的右节点都大于该节点，如果数满足这种条件则称之为有序二叉树。比如下面这就是一颗有序二叉树。

        

 这是树结点的代码，一个结点有他的左子树与右子树以及该节点对应的值

public class Tree {
    public Tree left=null;
    public Tree right=null;
    public int value;

}

 这是我的有序树，其中，treeNode指的是这棵树的根结点，fisrtOut等4个方法分别对应四种遍历方式。

public class OrderlyTree {
    public Tree treeNode=null;
    public Tree t;
    public void add(Tree x){
        if(treeNode==null){
            treeNode=x;
        }else{
            t=treeNode;
            while (t!=null){
                if(x.value<t.value){
                    if(t.left==null){
                        t.left=x;
                        break;
                    }else{
                        t=t.left;
                    }
                }else{
                    if(t.right==null){
                        t.right=x;
                        break;
                    }else{
                        t=t.right;
                    }
                }
            }
        }
    }

    public void firstOut(Tree x){
        if(x!=null){
            System.out.print(x.value+"   ");
            firstOut(x.left);
            firstOut(x.right);
        }
    }
    public void midOut(Tree x){
        if(x!=null){
            midOut(x.left);
            System.out.print(x.value+"   ");
            midOut(x.right);
        }
    }
    public void lastOut(Tree x){
        if(x!=null){
            lastOut(x.left);
            lastOut(x.right);
            System.out.print(x.value+"   ");
        }
    }
    public void layerlayerOut(Tree x){
        QueueDemo<Tree> q=new QueueDemo<Tree>();
        if(x==null){
            System.out.println("空");
        }else{
            q.add(x);
            while(!q.contains()){
                Tree tt=q.get();
                System.out.print(tt.value+"   ");
                if(tt.left!=null){
                    q.add(tt.left);
                }
                if(tt.right!=null){
                    q.add(tt.right);
                }
            }
        }
    }

}

 而最后一个层次遍历我们需要用到一个队列结构，他是我自己创建的一个泛型队列，代码如下：

public class QueueDemo<E>{
    private E[] arr=(E[]) new Object[20];
    private int frist=0;
    private int last=0;
    private int flag=0;
    public void add(E x){
        if(frist==last&&flag!=0){
            E[]arrx=(E[]) new Object[arr.length*2];
            int j=0;
            for(int i=frist;i<arr.length;i=(i+1)%arr.length){
                arrx[j]=arr[i];
                j++;
            }
            frist=0;
            last=j;
            arr=arrx;
        }
        arr[last]=x;
        last=(last+1)%arr.length;
        flag++;
    }
    public E get(){
        if(flag>0){
            E x=arr[frist];
            flag--;
            frist=(frist+1)%arr.length;
            return x;
        }else{
            return null;
        }
    }
    public boolean contains(){
        if(flag==0){
            return true;
        }else{
            return false;
        }
    }
}

 主方法：

public static void main(String[] args) {
        OrderlyTree o=new OrderlyTree();
        int[] arr={7,5,6,9,4,2,3,5};
        for(int i:arr){
            Tree t=new Tree();
            t.value=i;
            o.add(t);
        }
        System.out.println("先序遍历");
        o.firstOut(o.treeNode);
        System.out.println();
        System.out.println("中序遍历");
        o.midOut(o.treeNode);
        System.out.println();
        System.out.println("后序遍历");
        o.lastOut(o.treeNode);
        System.out.println();
        System.out.println("层次遍历");
        o.layerlayerOut(o.treeNode);

    }

通过主方法我们可以大致画出插入后的图

我们最开始插入时，没有结点，于是第一个数7成为了根节点，往后每个节点进来时，都先和7比较，比7大找他的左边，比7大或等于找他的右边，这样我们就创建了一颗有序二叉树。

但这个份代码是不好的，因为这棵树不是一颗平衡二叉树，关于平衡二叉树的知识点我另外整理了一边博客，因为我们可能出现一种情况插入的树是几乎有序，就会出现一头深度非常大，另一头缺只有1，2个，所以我们需要另外写代码实现他的平衡，但我这先不涉及

四种遍历

 1、先序遍历，也叫先根遍历，先访问它的根节点，在访问他的左节点，最后访问他的右节点

 2、中序遍历，也叫中根遍历，先访问它的左节点，在访问他的根节点，最后访问他的右节点

 3、后序遍历，也叫后根遍历，先访问它的左节点，在访问他的右节点，最后访问他的根节点

 5、层次遍历，一层一层从左到右遍历