java数据结构折半查找和二叉排序树

文中内容来源于《数据结构 --Java语言描述》（第二版） 刘小晶 杜选 主编
此系列文章作为学校实验记录，若文中内容有误，请大家指出，谢谢

一、实验目的

1、掌握查找的特点。
2、掌握折半查找的基本思想及其算法。
3、熟悉二叉排序树的特点，掌握二叉排序树的插入、删除操作。

二、实验内容

1、设有关键字序列k={ 5 ,14 ,18 ,21 ,23 ,29 ,31 ,35 }，查找key=21和key=25的数据元素。
2、根据关键字序列{45、24、53、12、37、93}构造二叉排序树，并完成插入13删除关键字53和24的操作。

三、实验步骤

1、折半查找
（1）从键盘输入上述8个整数5 ,14 ,18 ,21 ,23 ,29 ,31 ,35，存放在数组bub[8]中，并输出其值。
（2）从键盘输入21，查找是否存在该数据元素，若存在，则输出该数据元素在表中的位置，否则给出查找失败的信息。
（3）从键盘输入25，查找是否存在该数据元素，若存在，则输出该数据元素在表中位置，否则给出查找失败的信息。
2、二叉排序树
（1）二叉排序树存储定义
（2）从键盘上输入六个整数45、24、53、12、37、9构造二叉排序树
（3）输出其中序遍历结果。
（4）插入数据元素13，输出其中序遍历结果。
（5）删除数据元素24和53，输出其中序遍历结果。

源代码

//顺序表记录结点类
package ch7;
public class ElementType {
   
    public Object data;

    public ElementType(Object data) {
   
        this.data = data;
    }
    public ElementType() {
   
    }
    public String toString() {
   
        return (String)data;
    }
}


//顺序表记录关键字类
package ch7;
public class KeyType implements Comparable<KeyType> {
   
    public int key;
    public KeyType() {
   

    }
    public KeyType(int key) {
   
        this.key = key;
    }
    public String toString() {
   
        return key + "";
    }
    //覆盖Comparable接口中比较关键字大小的方法
    public int compareTo(KeyType another) {
   
        int thisVal = this.key;
        int anotherVal = another.key;
        if(thisVal<anotherVal) {
   
            return -1;
        } else {
   
            if(thisVal == anotherVal) {
   
                return 0;
            } else {
   
                return 1;
            }
        }
    }
}


//待排序的顺序表记录类
package ch7;
public class RecordNode {
   
    public Comparable key;
    public Object element;
    public RecordNode(Comparable key) {
   
        this.key = key;
    }
    public RecordNode(Comparable key,Object element) {
   
        this.key = key;
        this.element = element;
    }
    public String toString() {
   
        return "[" + key + "]";
    }
}


//待排序的顺序表类
package ch7;
import java.util.Scanner;
public class SeqList {
   
    public RecordNode[] r;//顺序表记录结点数组
    public int curlen;//顺序表长度，即记录个数
    //顺序表的构造方法，构造一个存储空间容量为maxSize的顺序表
    public SeqList(int maxSize) {
   
        this.r = new RecordNode[maxSize];
        this.curlen = 0;
    }
    //在当前顺序表的第i个结点之前插入一个RecordNode类型的结点x
    public void insert(int i,RecordNode x) throws Exception{
   
        if(curlen == r.length) {
   
            throw new Exception("顺序表已满！");
        }
        if(i<0 || i>curlen) {
   
            throw new Exception("插入位置不合法！");
        }
        for (int j = curlen; j > i; j--) {
   
            r[j] = r[j - 1];//插入位置及之后的数据元素后移
        }
        r[i] = x;//插入x
        this.curlen++;//表长度增1
    }
/*
二分查找的递归写法
public int binarySearchDG(int low,int high,Comparable key) {
    int mid;
    if(low<=high) {
        mid = low + high;
        if(r[mid].key.compareTo(key)>0) {
            return binarySearchDG(low,mid - 1,key);
        } else if(r[mid].key.compareTo(key)<0) {
            return binarySearchDG(mid + 1,high,key);
        } else {
            return mid;
        }
    }
    return -1;
}
*/

    public int binarySearch(Comparable key) {
   
        if(curlen>0) {
   
            int low = 0,high = curlen - 1;//查找范围上下界
            while(low<=high)