完全哈希C++实现

完全哈希
基本思想：完全哈希采用二级结构，每一级上都采用 全域散列。其实犹如用链表解决碰撞的哈希表那样，只不过完全哈希不是使用链表而是使用一 个小的哈希表来实现，且保证在小的哈希表上不发生碰撞

第一级按照正常全域哈希即可，第二级哈希表大小由此处碰撞个数n_i决定，m_i = n_i^2，碰撞个数要缩减到最小，否则造成极大浪费。
第一级哈希的槽中储存着二级哈希函数，二级也与一级类似。

中心思想就是在第一次的时候先找到元素要插入的地方的开头，然后将开头带回来，再去插入。

#include
#include
#include<stdlib.h>
#include<time.h>
using namespace std;

#define random(x)(rand()%x)

const int m = 16;

const int n = 13;

typedef int KeyType;

typedef int InfoType;

typedef struct
{
KeyType key;
InfoType otherinfo;
int Hashtable[m];
}HashTable[m];

typedef struct
{
KeyType key;
HashTable Hashtable;
}HashTablee[m];

//完美哈希表第一级查找
int Insertliuyu(HashTable Ht, KeyType key)//除数留余法
{
int Ho = key % n;//n为小于表长的最大质数
if (Ht[Ho].key == 0)
{
return Ho;
}
else
return -1;
}

//开放定址法

int Insertding1(HashTable Ht, KeyType key)//线性探测再散列
{

	int Ho = key % n;//n为小于表长的最大质数
	int Hi;
	for (int i = 0; i < m; i++)
	{
		Hi = (Ho + i) % m;
		if (Ht[Hi].key == 0)
		{
			return Hi;
		}

	}
	return -1;

}

int Insertding2(HashTable Ht, KeyType key)//二次探测再散列
{
int Ho = key % n;//n为小于表长的最大质数
int Hi;
for (int i = 0; i < m / 2; i++)
{
Hi = (Ho + i * i) / m;
if (Ht[Hi].key == 0)
{
return Hi;
}
else
{
Hi = (Ho - i * i) / m;
if (Ht[Hi].key == 0)
{
return Hi;
}
}
}
return -1;

}

int Insertding3(HashTable Ht, KeyType key)//伪随机探测再散列
{

	int Hi;
	srand((int)time(0));
	int q = m;
	while (q--)
	{
		Hi = random(m);
		if (Ht[Hi].key == 0)
		{
			return Hi;
		}
	}

	return -1;

}

int AllHash(HashTable Ht, KeyType key)//全域哈希
{
srand((int)time(0));
int flage = -1;
while (flage==-1)
{
int q = random(4);
if (q == 0)
{
flage = Insertliuyu(Ht, key);
}
else if (q == 1)
{
flage = Insertding1(Ht, key);
}
else if (q == 2)
{
flage = Insertding2(Ht, key);
}
else if (q == 3)
{
flage = Insertding3(Ht, key);
}
}
if (flage !=-1)
return flage;
else
return -1;
}
//第一级结束
//
//
//完美哈希表第二级

int Insertliuyu1(int Ht[], KeyType key)//除数留余法
{
int Ho = key % n;//n为小于表长的最大质数
if (Ht[Ho] == 0)
{
Ht[Ho] = key;
return 1;
}
else
return 0;
}

//开放定址法

int Insertding11(int Ht[], KeyType key)//线性探测再散列
{

int Ho = key % n;//n为小于表长的最大质数
int Hi;
for (int i = 0; i < m; i++)
{
	Hi = (Ho + i) % m;
	if (Ht[Hi] == 0)
	{
		Ht[Hi] = key;
		return 1;
	}

	
}
return 0;

}

int Insertding21(int Ht[], KeyType key)//二次探测再散列
{
int Ho = key % n;//n为小于表长的最大质数
int Hi;
for (int i = 0; i < m / 2; i++)
{
Hi = (Ho + i * i) / m;
if (Ht[Hi] == 0)
{
Ht[Hi] = key;
return 1;
}
else
{
Hi = (Ho - i * i) / m;
if (Ht[Hi] == 0)
{
Ht[Hi] = key;
return 1;
}
}
}
return 0;

}

int Insertding31(int Ht[], KeyType key)//伪随机探测再散列
{

int Hi;
srand((int)time(0));
int q = m;
while (q--)
{
	Hi = random(m);
	if (Ht[Hi] == 0)
	{
		Ht[Hi] = key;
		return 1;
	}
}

return 0;

}

int AllHash1(int Ht[], KeyType key)//全域哈希
{
srand((int)time(0));
int flage = 0;
while (flage != 1)
{
int q = random(4);
if (q == 0)
{
flage = Insertliuyu1(Ht, key);
}
else if (q == 1)
{
flage = Insertding11(Ht, key);
}
else if (q == 2)
{
flage = Insertding21(Ht, key);
}
else if (q == 3)
{
flage = Insertding31(Ht, key);
}
}
if (flage == 1)
return 1;
else
return 0;
}
//第二级结束

//完美哈希表调用
int PrefectHash(HashTable Ht, KeyType key)
{
int qq = AllHash(Ht, key);
int q=AllHash1(Ht[qq].Hashtable, key);
return 1;
}

int main()
{
HashTable HT;
for (int i = 0; i < m; i++)
{
HT[i].key = 0;
for (int j = 0; j < m; j++)
{
HT[i].Hashtable[j] = 0;
}
}

//插入
PrefectHash(HT, 19);
PrefectHash(HT, 14);
PrefectHash(HT, 23);
PrefectHash(HT, 1);
PrefectHash(HT, 68);
PrefectHash(HT, 20);
PrefectHash(HT, 84);
PrefectHash(HT, 27);
PrefectHash(HT, 55);
PrefectHash(HT, 11);
PrefectHash(HT, 10);
PrefectHash(HT, 79);
PrefectHash(HT, 80);
PrefectHash(HT, 54);

for (int i = 0; i < 16; i++)
{
	for (int j = 0; j < 16; j++)
	{
		cout << HT[i].Hashtable[j] << " ";
	}

	cout << endl;
}

}