二叉排序树BST

今天没花20分钟，就把BST的代码写出来了。毕竟寒假学了一遍，脑子里有影响，也很好理解。

只是出现了两个问题：

　　1.我在编写while循环的时候，就想到了新建叶子节点之后就break。但是，我又“机智”的想到，while（parent！=null）语句就可以检测循环的结束了，不关有没有新建叶子节点，都可以直接写parent=parent.child语句，进入下一个循环。因为如果没有新建叶子节点，parent就会变成null，从而跳出循环。

　　但是我想错了。如果找到了并新建叶子节点，再执行parent=parent.child语句就会使parent变成新建的那个节点，从而无线循环下去。（我按了F5等着出结果呢，结果风扇沙沙吹，CPU快烧坏了）

　　解决方法：加入break语句。

　　总结：算法结构不能想当然。以及懂的调试。

　　2.我调用以前写的 toString 函数进行打印。结果出现空指针错误。经查是一个老bug，浪费了很多时间。

　　

BST的Java代码：

class SearchBST extends BTtree{//二叉查找树
    SearchBST(int[] nums){//由二维数组构造
        root.data=String.valueOf(nums[0]);//构造根节点
        for(int i=1;i<nums.length;i++){//对其他元素进行构造
            BTNode node=new BTNode();
            node.data=String.valueOf(nums[i]);//构造叶子节点
            BTNode parent=root;
            int nodeV=nums[i];
            while(parent!=null){
                int parentV=Integer.valueOf(parent.data).intValue();//当前根节点的值
                if(nodeV<parentV){//左叶子
                    if(parent.lChild==null){//当前根节点的左叶子非空
                        parent.lChild=node;//挂入节点
                        break;                //如果这里没有加【break】，就会死循环。待解决☆☆☆
                    }
                    parent=parent.lChild;//如果这里空了，跳出循环
                }else{
                    if(parent.rChild==null){
                        parent.rChild=node;//挂入节点
                        break;                //☆☆☆
                    }
                    parent=parent.rChild;//如果这里空了，跳出循环                    
                }
            }
        }
    }
    SearchBST(){}
}

打印输出：（*代表空）

补充一个递归算法：

    void AVLinsert(BTNode node,BTNode parent,boolean isLeft,String data){
        int dataV=Integer.valueOf(data).intValue();
        int nodeV=0;
        if(node!=null) nodeV=Integer.valueOf(node.data).intValue();
        BTNode newNode=new BTNode();
        newNode.data=data;
        if(node==null){
            if(isLeft) parent.lChild=newNode;
            else        parent.rChild=newNode;
        }
        else if(dataV<nodeV){//向左插入
            AVLinsert(node.lChild,node,true,data);
        }else{
            AVLinsert(node.rChild,node,false,data);
        }
    }

完整代码：

import java.util.*;

public class demo {
    public static void main(String args[]){
        BTtree tree=new BTtree(3);
        tree.InOrderTraversal();
        System.out.print(tree);
        BThrTree thrTree=new BThrTree(tree);
        thrTree.InOrderTraversal();
        thrTree.InThreadingFabric();
        thrTree.InOrderTraversal_Thr();
        int []nums={45,12,53,3,37,24,100,61,90,78};
        SearchBST bst=new SearchBST(nums);
        bst.PreOrderTraversal();
        System.out.println(bst);
    //    thrTree.InOrderTraversal_Thr();
    }
}

class BTtree{//二叉树类
    class BTNode{//节点类
        String data=new String("0");;
        BTNode lChild=null;
        BTNode rChild=null;
        boolean LTag=false;//=0 : 指向左孩子。 =1 : 指向前驱
        boolean RTag=false;//=0 : 指向右孩子。 =1 : 指向后继
    }
    protected BTNode root=new BTNode();
    BTtree(){
    }
    BTtree(int layer){
        //用队列的方式构造n层树
        List<BTNode> queue=new ArrayList<BTNode>();
        int front=0;
        int rear=0;//队尾插入
        queue.add(root);//初始化入队
        rear++;
        int i , k=0 , j;
        for(j=0;j<layer;j++){
            int nowRear=rear;
            for(i=front;i<nowRear;i++){
                //出队，生两个孩子
                BTNode parent=queue.get(front++);
                BTNode lChild=new BTNode();
                lChild.data=Integer.toString(++k);
                BTNode rChild=new BTNode();
                rChild.data=Integer.toString(++k);
                parent.lChild=lChild;
                parent.rChild=rChild;
                queue.add(lChild);
                rear++;
                queue.add(rChild);
                rear++;
            }
        }
    }
    BTtree(String express){//通过中缀表达式进行构造
        //1.对表达式进行括号补全。
        
        
    }
    public String toString(){//重写打印函数
        List<BTNode> queue=new ArrayList<BTNode>();
        List<String[]> PrintList=new ArrayList<String[]>();
        int front=0;
        int rear=0;//队尾插入
        queue.add(root);//初始化入队
        rear++;
        int i , k=0 , j;
        
        String emptySignal=new String("");//空信号
        
        String str[]=new String[1];
        str[0]=root.data;
        PrintList.add(str);//打印数据结构初始化
        int layer=1;//下一层字符串的数目是2^1=2。
        int pos=0;
        
        boolean flag=true;
        ok:
        while(flag){
            pos=0;//pos初始化
            String tmp[]=new String[(int)Math.pow((int)2, (int)(layer++))];//length=2^layer
            flag=false;        //循环标志初始化
            int nowRear=rear;
            int nowFront=front;
            for(i=front;i<nowRear;i++){
                String nowStr=new String();
                BTNode parent=queue.get(front++);
                if(parent==null) break ok;    //跳出两重循环
                if(parent.data.equals(emptySignal)){//如果是空的，派生出两个空孩子
                    for(int t=0;t<2;t++){
                        tmp[pos++]="*";
                        BTNode empty=new BTNode();
                        empty.data=emptySignal;
                        queue.add(empty);rear++;
                    }
                }else{
                    if(parent.lChild!=null){
                        flag=true;                    //只要这一层存在孩子，就可以继续循环下去。
                        queue.add(parent.lChild);
                        tmp[pos++]=parent.lChild.data;
                        rear++;
                    }else{
                        tmp[pos++]="*";
                        BTNode empty=new BTNode();
                        empty.data=emptySignal;
                        queue.add(empty);
                        rear++;
                    }
                    if(parent.rChild!=null){
                        flag=true;
                        queue.add(parent.rChild);
                        tmp[pos++]=parent.rChild.data;
                        rear++;
                    }else{
                        tmp[pos++]="*";
                        BTNode empty=new BTNode();
                        empty.data=emptySignal;
                        queue.add(empty);
                        rear++;
                    }
                }
            }                // end of for
            PrintList.add(tmp);
        }                    // end of while
        /*
        for(i=0;i<PrintList.size();i++){
            for(j=0;j<PrintList.get(i).length;j++) System.out.print(PrintList.get(i)[j]+" ");
            System.out.println();
        }*/
        //后处理
        String[] PrintListLine=new String[PrintList.size()-1];
        for(i=PrintListLine.length-1;i>=0;i--){//循环构造
            //首先进行构造
            String tmp=new String();
            for(j=0;j<PrintList.get(i).length;j++){
                tmp+=PrintList.get(i)[j];
                if(j!=PrintList.get(i).length-1) tmp+=" ";
            }
            PrintListLine[i]=tmp;
        }
        for(i=PrintListLine.length-2;i>=0;i--){//居中操作
            int spaceNum=(PrintListLine[i+1].length()-PrintListLine[i].length())/2;
            String space=new String();
            for(int t=0;t<spaceNum;t++) space+=" ";
            PrintListLine[i]=space+PrintListLine[i]+space;
        }    
        String outStr=new String();
        for(i=0;i<PrintListLine.length;i++){//最后构造一个字符串
            outStr+=PrintListLine[i]+"
";
        }
        return outStr;
    }
    void PreOrderTraversal(){
        PreOrder(root);
        System.out.println();
    }
    void PreOrder(BTNode obj){
        if(obj!=null){
            System.out.print(obj.data+",");
            PreOrder(obj.lChild);
            PreOrder(obj.rChild);
        }
    }
    void InOrderTraversal(){
        InOrder(root);
        System.out.println();
    }
    void InOrder(BTNode obj){    
        if(obj!=null){
            InOrder(obj.lChild);
            System.out.print(obj.data+",");
            InOrder(obj.rChild);
        }
    }
}



//线索二叉树
class BThrTree extends BTtree{
    BThrTree(BTtree obj){//由父类构造而来
        //首先拷贝根节点
        BTNode tmp=new BTNode();
        tmp.data=obj.root.data;
        copy(root,obj.root);
    }
    void copy(BTNode node1,BTNode node2){
        if(node2.lChild!=null){//左树递归
            BTNode l=new BTNode();
            l.data=node2.lChild.data;//拷贝左树    
            node1.lChild=l;//左树赋值            
            copy(node1.lChild,node2.lChild);
        }
        if(node2.rChild!=null){//右树递归
            BTNode r=new BTNode();
            r.data=node2.rChild.data;//拷贝右树
            node1.rChild=r;//右树赋值
            copy(node1.rChild,node2.rChild);
        }    
    }
    public void InThreadingFabric(){//中序线索化构造
        BTNode now=root;
        InThreading(now); 
        pre.RTag=true;//【最后一个后继为null】
        pre.rChild=null;
    }
    private BTNode pre=null;//前驱指针
    private void InThreading(BTNode node){//中序线索化递归
        if(node!=null){//保证节点非空
            InThreading(node.lChild);//左子树线索化
            if(node.lChild==null){//如果左子树不存在
                node.LTag=true;//线索化
                node.lChild=pre;//前驱    【第一个前驱为null】
            }
            if(pre!=null && pre.rChild==null){//后继
                pre.RTag=true;
                pre.rChild=node;
            }
            pre=node;//保持pre指向node的前驱。
            InThreading(node.rChild);//左子树线索化
        }
    }
    void InOrderTraversal_Thr(){//线索化遍历
        BTNode now=root;
        //遍历前驱
        while(now.lChild!=null){//要么有左子树。
            now=now.lChild;
        }
        while(now!=null){//要么有左子树。
            System.out.print(now.data+",");
            if(now.RTag){now=now.rChild;}//如果是后继，就继续后继。
            else{
                now=now.rChild;//如果不是，则令右子树的最左节点为后继
                while(!now.LTag) now=now.lChild;
            }
        }
        System.out.println();
    }
}


class SearchBST extends BTtree{//二叉查找树
    SearchBST(int[] nums){//由二维数组构造
        root.data=String.valueOf(nums[0]);//构造根节点
        for(int i=1;i<nums.length;i++){//对其他元素进行构造
            BTNode node=new BTNode();
            node.data=String.valueOf(nums[i]);//构造叶子节点
            BTNode parent=root;
            int nodeV=nums[i];
            while(parent!=null){
                int parentV=Integer.valueOf(parent.data).intValue();//当前根节点的值
                if(nodeV<parentV){//左叶子
                    if(parent.lChild==null){//当前根节点的左叶子非空
                        parent.lChild=node;//挂入节点
                        break;                //如果这里没有加【break】，就会死循环。待解决☆☆☆
                    }
                    parent=parent.lChild;//如果这里空了，跳出循环
                }else{
                    if(parent.rChild==null){
                        parent.rChild=node;//挂入节点
                        break;                //☆☆☆
                    }
                    parent=parent.rChild;//如果这里空了，跳出循环                    
                }
            }
        }
    }
    SearchBST(){}
}