hash表、hash算法

概念：

散列表（Hash table。也叫哈希表），是依據關鍵碼值(Key value)而直接進行訪問的 數據結構。

也就是說，它經過把關鍵碼值映射到表中一個位置來訪問記錄，以加快查找的速度。這個映射函數叫作散列函數，存放記錄的數組叫作散列表。給定表M，存在函數f(key)。對隨意給定的keyword值key。代入函數後若能獲得包括該keyword的記錄在表中的地址，則稱表M爲哈希(Hash）表。函數f(key)爲哈希(Hash) 函數

 

散列函數的選取：

1.  直接尋址法：取keyword或keyword的某個線性函數值爲散列地址。

即H(key)=key或H(key) = a·key + b，當中a和b爲常數（這樣的散列函數叫作自身函數）。

若當中H(key）中已經有值了，就往下一個找。直到H(key）中沒有值了。就放進去。

2. 數字分析法：分析一組數據。比方一組員工的出生年月日。這時咱們發現出生年月日的前幾位數字大致一樣，這種話。出現衝突的概率就會很是大，但是咱們發現年月日的後幾位表示月份和詳細日期的數字區別很是大，假設用後面的數字來構成散列地址，則衝突的概率會明顯減小。所以數字分析法就是找出數字的規律，儘量利用這些數據來構造衝突概率較低的散列地址。

3. 平方取中法：取keyword平方後的中間幾位做爲散列地址。

4. 摺疊法：將keyword切割成位數一樣的幾部分，最後一部分位數可以不一樣，而後取這幾部分的疊加和（去除進位）做爲散列地址。數位疊加可以有移位疊加和間界疊加兩種方法。移位疊加是將切割後的每一部分的最低位對齊，而後相加。間界疊加是從一端向還有一端沿切割界來回摺疊，而後對齊相加。

5. 隨機數法：選擇一 隨機函數。取keyword的隨機值做爲散列地址。通常常使用於keyword長度不一樣的場合。

6. 除留餘數法：取keyword被某個不大於 散列表表長m的數p除後所得的餘數爲散列地址。

即 H(key) = key MOD p,p<=m。不只可以對keyword直接取模，也可在摺疊、平方取中等運算以後取模。對p的選擇很是重要，通常取素數或m，若p選的很差，easy產生同義詞。

處理衝突的方式：

1.開放尋址法：出現衝突時採用線性試探、僞隨機試探等方式。

2.公共溢出區法：將衝突元素直接放入公共溢出區（公共溢出區也可以進行散列）.

3.拉鍊法（鏈地址法）:哈希表的每個元素都是一個鏈表。出現衝突時直接掛到相應位置的鏈表上。

4.在散列法：再準備若干哈希函數。出現衝突時，使用其它哈希函數進行散列。

實現：

線性哈希表(採用了線性試探解決衝突問題)

/******************************
線性hash表
by Rowandjj
2014/7/14
******************************/
#include<iostream>
using namespace std;
#define MAX 20//hash表大小
typedef int DataType;
typedef struct _NODE_
{
	DataType data;//方便起見，直接用int型。實際應用時應該是隨意類型的
	int flag;//1表明已有數據，0表明無數據
}HashNode,*pHashNode;
typedef struct _HASHTABLE_
{
	pHashNode pHashNodeTemp;//實際存儲數據的hash數組
	int n;//hash表大小(總容量)
	int cur_elem;//當前容量
}HashTable,*pHashTable;
int hashFunc(DataType key)//hash函數
{
	int index = key/3+1;
	index = (index < 0) ? -index : index;
	return index;
}
bool CreateHashTable(pHashTable pHashTableTemp);
bool DestroyHashTable(pHashTable pHashTableTemp);
void InsertHashTable(pHashTable pHashTableTemp,DataType data,int (*hashFunc)(DataType));
int StatHashTable(HashTable HashTableTemp);//統計空項
void PrintHashTable(HashTable HashTableTemp);//輸出hash表中的值
int SearchKey(HashTable HashTableTemp,DataType data,int (*hashFunc)(DataType));//依據數據查找其索引
int main()
{
	int i;
	int a[] = {9,31,26,1,13,2,11};
	cout<<"原始序列:"<<endl;
	for(i = 0; i < 7; i++)
	{
		cout<<a[i]<<" ";
	}
	cout<<endl;
	HashTable hashTable;
	CreateHashTable(&hashTable);
	for(i = 0; i < 7; i++)
	{
		InsertHashTable(&hashTable,a[i],hashFunc);
	}
	cout<<"散列後的序列:"<<endl;
	PrintHashTable(hashTable);
	DataType data;
	while(cin>>data)
	{
		if(data == -1)
		{
			break;
		}
		cout<<"index = "<<SearchKey(hashTable,data,hashFunc);
	}
		
	DestroyHashTable(&hashTable);
	return 0;
}
bool CreateHashTable(pHashTable pHashTableTemp)
{
	if(!pHashTableTemp)
	{
		return false;
	}
	pHashTableTemp->pHashNodeTemp = (pHashNode)malloc(sizeof(HashNode)*MAX);
	if(!pHashTableTemp->pHashNodeTemp)
	{
		return false;
	}
	else
	{
		pHashTableTemp->n = MAX;
		pHashTableTemp->cur_elem = 0;
		for(int i = 0; i < pHashTableTemp->n; i++)
		{
			pHashTableTemp->pHashNodeTemp[i].flag = 0;
			pHashTableTemp->pHashNodeTemp[i].data = -1;
		}
	}
	return true;
}
bool DestroyHashTable(pHashTable pHashTableTemp)
{
	if(pHashTableTemp != NULL)
	{
		free(pHashTableTemp->pHashNodeTemp);
		pHashTableTemp->pHashNodeTemp = NULL;
		pHashTableTemp->n = 0;
	}
	return true;
}
void InsertHashTable(pHashTable pHashTableTemp,DataType data,int (*hashFunc)(DataType))
{
	if(!pHashTableTemp)
	{
		return;
	}
	if(StatHashTable(*pHashTableTemp) == 0)//當hash表滿了的時候。可以選擇擴容，這裏直接返回 
	{
		cout<<"hash表已滿..."<<endl;
		return;
	}
	int index = hashFunc(data) - 1;
	while(pHashTableTemp->pHashNodeTemp[index].flag)//衝突時採用的是線性試探法
	{
		index = (index + 1)% pHashTableTemp->n;//防止越界
	}
	pHashTableTemp->pHashNodeTemp[index].data = data;
	pHashTableTemp->pHashNodeTemp[index].flag = 1;
	pHashTableTemp->cur_elem++;
}
int StatHashTable(HashTable HashTableTemp)
{
	int i,count = 0;
	for(i = 0; i < HashTableTemp.n; i++)
	{
		if(HashTableTemp.pHashNodeTemp[i].flag == 0)
		{
			count++;
		}
	}
	return count;
}
void PrintHashTable(HashTable HashTableTemp)
{
	int i;
	for(i = 0; i < HashTableTemp.n; i++)
	{
		cout<<HashTableTemp.pHashNodeTemp[i].data<<" ";
	}
	cout<<endl;
}
int SearchKey(HashTable HashTableTemp,DataType data,int (*hashFunc)(DataType))
{
	int index = hashFunc(data)-1;
	int times = 0;
	while(HashTableTemp.pHashNodeTemp[index].flag && HashTableTemp.pHashNodeTemp[index].data != data)
	{
		index = (index + 1)% HashTableTemp.n;
		times ++;
		if(times == HashTableTemp.n)
		{
			return -1;//沒找到
		}
	}
	return index;
}

測試：