查找方法实现

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;
    }
  

}