参考 严蔚敏 数据结构(c语音版)
动态查找表有：二叉排序树，平衡二叉树，B_树，B+树，键树，哈希表
动态查找表是相对静态查找表，表结构的本身是在动态过程中动态生成的，即给定关键值key,若查找成功则返回，否则插入值key.
二叉排序树：空树或是由以下特征：
1.左子树不为空，则左子树上所有节点值均小于它根节点的值
2.右子树不为空，则右子树上所有节点值均大于它根节点的值
3.它的左右子树叶分别为二叉排序树
ADT{//简单的抽象数据类型
数据对象：//所定义的对象DST含有内部的二叉链表结构的静态属性，并提供相关操作。JDK1.5以上，支持基础数据类型的自动封装，泛型
public class DST<T>{
private static class DSTNode<U>{
U data; //节点值
DSTNode leftNode; //左子树
DSTNode rightNode; //右子树
int index; //节点下标
}
}
操作方法(访问权限public)：
//void initDST(T table):初始化二叉排序树,T为java对象类型，由DST的构造函数实现
void insertDST(T table，U key):插入关键值key,U为java对象类型
int searchDST(T table,U key):查找操作，返回值的位置
void deleteDST(T table,U key):删除关键值key.
//traverseDST(T table)：// 遍历节点，并调用内部visit(DSTNode node)对节点进行操作
//private visit(DSTNode node) :对节点操作的应用函数
//destroyDST(T table): 销毁操作
}
package test;
/**a
* 简单的二叉排序树查找
* @param <T>
*/
public class DST<T> {
private DSTNode<T> root;//定义头结点，相当与C中的指向对象基址
private volatile int keyIndex;
private int count; //记录总结点数
public int getCount(){
return count+1;//包括根节点
}
@SuppressWarnings("unchecked")
public DST(T data){
this.root=new DSTNode<T>();
root.data=data;
}
public DST(DSTNode<T> node,T data){
this.root=node;
this.root.data=data;
}
private static class DSTNode<U>{
U data; //结点值
DSTNode<U> leftNode; //左子树
DSTNode<U> rightNode; //右子树
int index; //为了查找时，能返回结点位置定义的结点下标
}
/**
* 插入key
* @param node 父类结点
*/
private void insertDST(DSTNode<T> node,T key){
if(node!=null){
DSTNode<T> newNode=new DSTNode<T>();
newNode.data=key;
if(gt(node.data,key)){
if(node.leftNode==null){
node.leftNode=newNode;
newNode.index=(++count);
}
}else if(lt(node.data,key)){
if(node.rightNode==null){
node.rightNode=newNode;
newNode.index=(++count);
}
}
}
}
/**
* 删除key
* @param table
* @param key
*/
public void deleteDST(DSTNode<T> node,T key){
//TODO
}
/**
* 查询key,查询成功返回下标，查询不成功返回-1并插入key
* @param table
* @param key
* @return
*/
public int searchDST(DSTNode<T> top,T key){
keyIndex=-1;
search(top,key);
return keyIndex;
}
private void search(DSTNode<T> top,T key){
if(top!=null){
if(eq(top.data,key)){
keyIndex=top.index;
}else if(gt(top.data,key)){
if(top.leftNode!=null)
search(top.leftNode,key);
}else if(lt(top.data,key)){
if(top.rightNode!=null)
search(top.rightNode,key);
}
//插入节点
insertDST(top,key);
}
return;
}
private boolean eq(T data,T key){
return (data==key||data.equals(key))?true:false;
}
private boolean lt(T data,T key){
return (data.hashCode()-key.hashCode()<0)?true:false;
}
private boolean gt(T data,T key){
return (data.hashCode()-key.hashCode()>0)?true:false;
}
public static void main(String[] args){
DST<Integer> d=new DST<Integer>(new Integer(15)); //初始化根节点值为15 index 0
int index=d.searchDST(d.root, 8); //index 1
int index_2=d.searchDST(d.root,16); //index 2
System.out.println("index="+index); //打印结果：初始根为15，查询不到8,返回-1
System.out.println("index="+index_2); //打印结果：树为根15和左孩子8，查询不到16,返回-1
int index_3=d.searchDST(d.root, 8);
System.out.println("index="+index_3); //打印结果：返回 index=1
int index_4=d.searchDST(d.root,7); //index 3
System.out.println("index="+index_4); //打印结果：返回 -1 ,不存在并插入7
int index_5=d.searchDST(d.root,7);
System.out.println("index="+index_5); //打印：结果返回 index=3
System.out.println(d.getCount()); //打印总结果返回 4个结点 分别是
/**
* 15
* /\
* 8 16
* /
* 7
*/
DST<String> a=new DST<String>(new String("cd"));
int a1=a.searchDST(a.root,"ab");
int a2=a.searchDST(a.root,"ec");
int a3=a.searchDST(a.root,"fd");
int a4=a.searchDST(a.root,"be");
int a5=a.searchDST(a.root,"bb");
int a6=a.searchDST(a.root,"ec");
System.out.println(a1); //结果：-1
System.out.println(a2); //结果：-1
System.out.println(a3); //结果：-1
System.out.println(a4); //结果：-1
System.out.println(a5); //结果：-1
System.out.println("index="+a6); //结果：index=2
System.out.println(a.getCount()); //结果:6
/**
* cd
* /\
* ab ec
* \ \
* be fd
* /
* bb
*/
}
}
