Hash 取模法构造hash函数及链地址法防冲突

在算法比赛中，经常会用到hash来处理快速搜索和判重的问题。这里举一个例子来说明。

思路如下：

　　（1）采用取模法构造哈希函数

       (2 ) 解决冲突采用链地址法。

数据举例：

需要被hash的数据列表为（19,14,23,01,68,20,84,27,55,11,10,79），取哈希函数为H（key）=key MOD 13。则预想结果应为：

( 以上数据来源：http://www.cnblogs.com/lpshou/archive/2012/05/08/2490191.html，感谢! )

一般在比赛中有两种使用场景:

一是原始所有的状态数据是不确定的（即在程序中一边计算，一边将其hash），程序中要将这些数据在hash的过程中存起来。如下面程序中的 TK数组。

package hash;

public class HashTest {
	
	public static final int hashsize=13;
	public static final int maxState=30;
	public static int[]  head=new int[hashsize];
	public static int[] next=new int[maxState];

	public static int[] data=new int[]{19,14,23,01,68,20,84,27,55,11,10,79};//准备好所有的数据
	
	public static int[] tk=new int[maxState]; //所有的hash值存在这里
	
	public static int tot=0;//维护当前hash值的索引，每存一个值加1
	
	public static int add(int data) {
		int key=data%hashsize;		
        if(find(data)!=-1) return -1; //如果存在，则不加返回失败
        tot++; //注意tk数组的下标将从1开始
		next[tot]=head[key];  
		head[key]=tot;
		tk[tot]=data;
		return 1;
	}
	
	//判重
	public static int find(int data) {
		int key=data%hashsize;
		for(int i=head[key]; i!=-1; i=next[i])
			if(tk[i]==data)return i;                                                                 
		return -1;
	}
	
	public static void main(String[] args) {
		//初始化head,next
		for(int i=0;i<head.length;i++) {head[i]=-1;}
		for(int i=0;i<next.length;i++) {next[i]=-1;}
		//准备测试数据,构造hash
		for(int i=0;i<data.length;i++) {
			add(data[i]);
		}
		//打印结果
		int index=find(55);//单值查找
		System.out.println(index);
		System.out.println("**********");
		for(int i=0;i<head.length;i++) {//遍历整个hash
			System.out.print("head"+i+" "+head[i]+" : ");
			for(int j=head[i]; j!=-1; j=next[j]){
				System.out.print(tk[j]+" ");
			}
			System.out.println();
		}
	}
}

结果：

9
**********
head0 -1 : 
head1 12 : 79 27 1 14 
head2 -1 : 
head3 9 : 55 68 
head4 -1 : 
head5 -1 : 
head6 7 : 84 19 
head7 6 : 20 
head8 -1 : 
head9 -1 : 
head10 11 : 10 23 
head11 10 : 11 
head12 -1 : 

另一种场景是所有状态已提前算好，只是将其hash，提高搜索速度和判重速度。

package hash;

public class HashTest2 {
	
	public static final int hashsize=13;
	public static final int maxState=30;
	public static int[]  head=new int[hashsize];
	public static int[] next=new int[maxState];

	public static int[] data=new int[]{19,14,23,01,68,20,84,27,55,11,10,79};//准备好所有的数据,也是所有状态
	
	//public static int[] tk=new int[maxState]; //不再需要	
	//public static int tot=0;//维护当前hash值的索引，每存一个值加1
	
	public static int add(int index) {
		int key=data[index]%hashsize;
        if(find(data[index])!=-1) return -1; //如果存在，则不加返回失败
		next[index]=head[key];  
		head[key]=index;
		return 1;
	}
	
	//判重
	public static int find(int value) {
		int key=value%hashsize;
		for(int i=head[key]; i!=-1; i=next[i])
			if(data[i]==value)return i;                                                                 
		return -1;
	}
	
	public static void main(String[] args) {
		//初始化head,next
		for(int i=0;i<head.length;i++) {head[i]=-1;}
		for(int i=0;i<next.length;i++) {next[i]=-1;}
		//准备测试数据,构造hash
		for(int i=0;i<data.length;i++) {
			add(i);  //这里改为只传状态的索引！
		}
		//打印结果
		int index=find(55);//单值查找
		System.out.println(index);
		System.out.println("**********");
		for(int i=0;i<head.length;i++) {//遍历整个hash
			System.out.print("head"+i+" "+head[i]+" : ");
			for(int j=head[i]; j!=-1; j=next[j]){
				System.out.print(data[j]+" ");
			}
			System.out.println();
		}
	}
}

结果：

8
**********
head0 -1 : 
head1 11 : 79 27 1 14 
head2 -1 : 
head3 8 : 55 68 
head4 -1 : 
head5 -1 : 
head6 6 : 84 19 
head7 5 : 20 
head8 -1 : 
head9 -1 : 
head10 10 : 10 23 
head11 9 : 11 
head12 -1 : 

一个为8，一个为9，只是索引起始一个从0开始，一个从1开始。  算法过程中根据需要加减1.