public class testSearch {
public static void main(String[] args) {
int n,f,e,num;int[] data;
Scanner read=new Scanner(System.in);
mySearch gg=new mySearch();
System.out.println("输入需要存储的数据个数");
n=read.nextInt();
data=new int[n];
System.out.println("输入需要存储的数据");
for(int i=0;i<n;i++)
data[i]=read.nextInt();
System.out.println("输入需要查找的数据");
num=read.nextInt();
System.out.println("------------------------");
System.out.println("操作选项菜单:");
System.out.println("1.线性查找");
System.out.println("2.树表查找技术");
System.out.println("3.哈希表查找技术");
System.out.println("0.退出");
System.out.println("------------------------");
do{
System.out.println("请输入操作选项:");
e=read.nextInt();
switch(e){
case 1:{
System.out.println("1.顺序查找 2.二分查找 3.分块查找");
f=read.nextInt();
if(f==1){
gg.seqSearch(data,num);
}else if(f==2){
gg.binSearch(data,num);
}else if(f==3){
gg.blockSearch(data,num);
}
break;
}
case 2:{
gg.binSearchTree(data,num);
}
case 3:{
gg.HashHableHearch(data,num);
}
}
}while(e!=0);
read.close();
}
}
主方法类 包含了顺序查找哈希查找 树形查找
public class mySearch {
//顺序查找
public void seqSearch(int[] data,int num){
int p;
System.out.println("顺序查找测试:");
for(p=0;p<data.length;p++){
System.out.print(p+" ");
if(num==data[p]){
break;
}
}
print(data,p);
}
//二分查找
public void binSearch(int[] data ,int num){
int low=0,high=data.length,mid;
int k=0;
System.out.println("二分查找测试:");
while(low<=high){
mid=(low+high)/2;
if(num==data[mid]){
k=mid;break;
}else if(num>data[mid]){
low=mid+1;
}else{
high=mid-1;
}
}
print(data,k);
}
//块查找
public void blockSearch(int[] data,int num){
int p=0;
//创建索引表
int len=data.length;
int n=(int)Math.sqrt(len);//每组大小
int m=(int)len/n;//分组数量
Block[] blocks=new Block[m];
for(int i=0;i<m;i++){
Block block=new Block();
block.begin=i*n;
if(i*n+n-1<len-1)
block.end=i*n+n-1;
else
block.end=len-1;
int maxvalue=data[block.begin];
for(int j=block.begin;j<block.end;j++){
if(maxvalue<data[j]) maxvalue=data[j];
}
block.maxvalue=maxvalue;
blocks[i]=block;
}
System.out.println("块查找测试:");
int blockindex=-1;
for(int i=0;i<blocks.length-1;i++){
if(num>=blocks[i].maxvalue&&num<=blocks[i+1].maxvalue){
blockindex=i+1;
break;
}
}
if(blockindex!=-1){
int index;
for(index=blocks[blockindex].begin;index<=blocks[blockindex].end;index++){
if(num==data[index]) p=index;
}
}
print(data,p);
}
static class Block{//静态内部类
int begin,end,maxvalue;//块数据 最小编号最大编号 最大编号对应的值
}
public static void print(int[] data,int x){
System.out.println("初始数字列队:");
for(int i=0;i<data.length;i++){
System.out.print(data[i]+" ");
}
System.out.println();
System.out.println("关键字"+data[x]+"在数据列表的下标是:"+x);
}
//二叉排序树
public void binSearchTree(int[] data,int num){
System.out.println("二叉排序树测试:");
Treenode root=null;
for(int i=0;i<data.length;i++){
root=insert(data[i],root);
}
boolean f=search(num,root);
System.out.println("初始数字列队:");
for(int i=0;i<data.length;i++){
System.out.print(data[i]+" ");
}
System.out.println();
System.out.println("have "+num+"-->"+f);
}
//是否包含某个元素
private boolean search(int key,Treenode t){
if(t==null){
return false;
}
if(key<t.key){
return search(key,t.left);
}else if(key>t.key){
return search(key,t.right);
}
return true;
}
//添加新节点
private Treenode insert(int key,Treenode t){
if(t==null){
return new Treenode(key,null,null);
}
if(key<t.key){
t.left=insert(key,t.left);
}else if(key>t.key){
t.right=insert(key,t.right);
}
return t;
}
//删除某个点
private Treenode remove(int key,Treenode t){
if(t==null){
return null;
}
if(key<t.key){
t.left=remove(key,t.left);
}else if(key>t.key){
t.right=remove(key,t.right);
}else if(t.left!=null&&t.right!=null){
t.key=findMin(t.right).key;
t.right=remove(t.key,t.right);
}else{
t=(t.left!=null)?t.left:t.right;
}
return t;
}
private Treenode findMin(Treenode t){
if(t==null){
return null;
}
if(t.left==null){
return t;
}
return findMin(t.left);
}
static class Treenode{//二叉树结构类
int key;
Treenode left,right;
Treenode(int key,Treenode left,Treenode right){
this.key=key;
this.left=left;
this.right=right;
}
}
//哈希表查找技术
//构造哈希函数方法 1平方取中法 2取余法 除数p接近sum的一个质数 3折叠移位法 顺折法 裁成几位相加进位舍去 对折法 中间对折相加
//解决哈希冲突 1开放地址法 线性探测法 探测位置 d d+1 d+2 ..m-1 0 1 ..d-1 h(key)=d 二次探查法 hi=(h(key)+i*i)%m 0<i<m-1
//2链表法 同义词连在一个结点的链表中 h(key)=key%13 相等的点连在一起
public void HashHableHearch(int[] data,int key){//除余法和链表法
int p=1;
int k;//哈希函数计算单元地址
//寻找小于或等于洁净表的素数
for(int i=data.length;i>1;i--){
for(int j=2;j<Math.sqrt(i);i++){
if(i%j==0)
break;
}
p=i;
break;
}
Node[] hashtable=new Node[p];
//用余链法构建哈希表
for(int i=0;i<data.length;i++){
Node node=new Node();
node.key=data[i];
node.next=null;
k=data[i]%p;
if(hashtable[k]==null){
hashtable[k]=node;
}else{
Node cur=hashtable[k];
while(cur.next!=null)
cur=cur.next;
cur.next=node;
}
}
//查找key是否在哈希表中
int h=key%p;
boolean f;
Node cur=hashtable[h];
while(cur!=null&& cur.key!=key)
cur=cur.next;
if(cur==null)
f=false;
else
f=true;
System.out.println("初始数字列队:");
for(int i=0;i<data.length;i++){
System.out.print(data[i]+" ");
}
System.out.println();
System.out.println("have "+key+"-->"+f);
}
static class Node{
int key;
Node next;
}
}