数据结构-哈希表

哈希表的定义:

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

哈希函数的析构方法
余数法：取关键字被某个不大于散列表表长m的数p除后所得的余数为散列地址。即 H(key) = key MOD p,p=m。不仅可以对关键字直接取模，也可在折叠、平方取中等运算之后取模。对p的选择很重要，一般取素数或m，若p选的不好，容易产生同义词。

直接定址法

取关键字或关键字的某个线性函数值为散列地址。即H(key)=key或H(key) = a·key b，其中a和b为常数（这种散列函数叫做自身函数）。若其中H(key）中已经有值了，就往下一个找，直到H(key）中没有值了，就放进去。

平方取中法:

取关键字平方后的中间几位作为散列地址。

折叠法

将关键字分割成位数相同的几部分，最后一部分位数可以不同，然后取这几部分的叠加和（去除进位）作为散列地址。数位叠加可以有移位叠加和间界叠加两种方法。移位叠加是将分割后的每一部分的最低位对齐，然后相加；间界叠加是从一端向另一端沿分割界来回折叠，然后对齐相加。

把关键字变换为整数等

处理冲突的方法

1. 开放寻址法：Hi=(H(key) di) MOD m,i=1,2，…，k(k=m-1），其中H(key）为散列函数，m为散列表长，di为增量序列，可有下列三种取法：

1.1. di=1,2,3，…，m-1，称线性探测再散列；

1.2. di=1^2,-1^2,2^2,-2^2，⑶^2，…，±（k)^2,(k=m/2）称二次探测再散列；

1.3. di=伪随机数序列，称伪随机探测再散列。

2. 再散列法：Hi=RHi(key),i=1,2，…，k RHi均是不同的散列函数，即在同义词产生地址冲突时计算另一个散列函数地址，直到冲突不再发生，这种方法不易产生“聚集”，但增加了计算时间。

3. 链地址法（拉链法）

4. 建立一个公共溢出区

下面我来建立一个哈希表

#include<stdlib.h>
#include<stdio.h>
#include<string.h>

typedef struct       //元素类型定义
{
	int key;//关键字
	int hi;//冲突次数




}DataType;  
typedef struct   //哈希表类型
{
	DataType *data;
	int tableSize;//哈希表的长度
	int curSize;//哈希表中关键字的个数

}HashTable;


void CreateHashTable(HashTable  *H, int m, int p, int hash[], int n);
void DisplayHash(HashTable *H, int m);
int SearchHash(HashTable *H, int k);


int main()
{
	int hash[] = { 23, 35, 12, 56, 123, 39, 342, 90 };
	int m = 11, p = 11, n = 8, pos;
	//m代表长度 p<=m为除数,n代表元素个数
	int k;
	HashTable H;
	CreateHashTable(&H, m, p, hash, n);
	DisplayHash(&H, m);
	k = 123;
	pos = SearchHash(&H, k);
	printf("关键字%d在哈希表中的位置为:%d\n", k, pos);
	system("pause");


	return 0;
}
void CreateHashTable(HashTable  *H, int m, int p, int hash[], int n)//m为哈希表长度
{     //sum冲突次数       
	int i, sum, addr, di, k = 1;
	(*H).data = (DataType*)malloc(m*sizeof(DataType));//为哈希表分配存储空间
	if (!(*H).data)
		exit(-1);
	for (i = 0; i < m; i++)//初始化哈希表
	{
		(*H).data[i].key = -1;
		(*H).data[i].hi = 0;

	}
	for (i = 0; i < n; i++)//求哈希函数的地址并处理冲突
	{
		sum = 0;//冲突的次数
		
		addr = hash[i] % p;//余数法求哈希函数地址
		di = addr;
		if ((*H).data[addr].key == -1)//如果不冲突,则将元素存储到表中
		{
			(*H).data[addr].key = hash[i];
			(*H).data[addr].hi = 0;
		}
		else//用线性探测再哈希法处理冲突
		{
			do 
			{
				di = (di + k) % m;
				sum++;
			} while ((*H).data[di].key!=-1);
			(*H).data[di].key = hash[i];
			(*H).data[di].hi = sum + 1;

		}
		(*H).tableSize = m;//哈希表的长度
		(*H).curSize = n;
	}

}
void DisplayHash(HashTable *H, int m)//显示哈希表
{
	int i;
	printf("哈希表地址:");
	for (i = 0; i < m; i++)
	{
		printf("%-5d", i);
	}
	printf("\n");
	printf("关键字key的值:");
	for (i = 0; i < m; i++)
	{
	printf("%-5d", (*H).data[i].key);
			
	}
	printf("\n");
	printf("冲突的次数");
	printf("     ");
	for (i = 0; i < m; i++)
	{
		
			printf("%-5d",(*H).data[i].hi);

	}
	printf("\n");
		

	}


int SearchHash(HashTable *H, int k)//在哈希表中查找关键字k的位置
{
	int d, dl, m;
	m = H->tableSize;
	d = dl = k*m;
	while (H->data[d].key != -1)
	{
		if (H->data[d].key == k)
		{
			return d;
		}
		else
		{
			d = (d + 1) % m;
			if (d == dl)
			{
				return 0;//说明没有找到
			}

		}
	}
}