平方探测是消除线性探测中聚集问题的冲突解决办法。平方探测就是冲突函数为二次函数的探测方法。流行的选择函数是F(i)=i²,例如插入89,18,49,58,69可以由下图看出,
空表 | 插入89 | 插入18 | 插入49 | 插入58 | 插入69 | |
0 | 49 | 49 | 49 | |||
1 | ||||||
2 | 58 | 58 | ||||
3 | 69 | |||||
4 | ||||||
5 | ||||||
6 | ||||||
7 | ||||||
8 | 18 | 18 | 18 | 18 | ||
9 | 89 | 89 | 89 | 89 | 89 |
而对于平方探测法来说,一旦表被填满超过一半,当表的大小不是素数时甚至在表被填满一半之前,就不能保证一次找到一个空单元。而对于平方探测法来讲,其和线性探测法一样,san'删除的操作只能用懒惰删除。下面为其代码:
fatal.h
#include <stdio.h>
#include <stdlib.h>
#define Error(Str) FatalError(Str)
#define FatalError(Str) fprintf(stderr, "%s\n", Str), exit(1)
hashquad.h
typedef char* ElementType;
#ifndef _Hashquad_H
#define _Hashquad_H
typedef unsigned int Index;
typedef Index Position;
struct HashTbl;
typedef struct HashTbl* HashTable;
HashTable initializeTable(int tableSize);
void destroyTable(HashTable h);
Position find(ElementType key, HashTable h);
HashTable insert(ElementType key, HashTable h);
HashTable rehash(HashTable h);
ElementType retrive(Position p,HashTable h);
#endif
hashquad.cpp
#include"hashquad.h"
#include"fatal.h"
#include<math.h>
#include<string.h>
#define MinTableSize 5
#define N 10000
int ranintArr[N];
enum KindOfEntry { Legitimate, Empty, Deleted };
struct HashEntry
{
ElementType element;
enum KindOfEntry info;
};
typedef struct HashEntry Cell;
struct HashTbl
{
int tableSize;//表的大小
int num;//判断插入元素的个数
Cell *theCells;//构建散列表项的单元数组
};
static int hash(ElementType key, int tableSize)
{
return key % (tableSize);
}
static int isPrime(int num) //判断素数
{
for (int i = 2; i <= sqrt(num); i++)
{
if (num%i == 0)
{
return 0;
}
}
return 1;
}
static int nextPrime(int num)//寻找素数作为表的大小
{
int i = num;
while (!isPrime(i))
{
i++;
}
return i;
}
HashTable initializeTable(int tableSize)//散列表的初始化
{
HashTable h;
int i;
if (tableSize < MinTableSize)
{
Error("Table size too small");
return NULL;
}
h = malloc(sizeof(struct HashTbl));
if (h == NULL)
{
FatalError("Out of space!!!");
}
h->tableSize = nextPrime(tableSize);
h->theCells = malloc(sizeof(Cell)*h->tableSize);
h->hasInsertedNum = 0;
if (h->theCells == NULL)
{
FatalError("Out of space!!!");
}
for (i = 0; i < h->tableSize; i++)
{
h->theCells[i].info = Empty;
}
return h;
}
void destroyTable(HashTable h) //删除散列表
{
free(h->theCells);
free(h);
}
Position find(ElementType key, HashTable h)//查找表中的元素
{
Position currentPos = hash(key, h->tableSize);
int collisionNum = 0;
while (h->theCells[currentPos].info != Empty && h->theCells[currentPos].element!= key)
{
++collisionNum;
currentPos = (currentPos +collisionNum*2-1) % h->tableSize;
}
return currentPos;
}
HashTable insert(ElementType key, HashTable h)//插入
{
if ((double)h->num / h->tableSize > 0.5)
{
h = rehash(h);
}
Position pos = find(key, h);
if (h->theCells[pos].info != Legitimate)
{
h->theCells[pos].element=key;
h->theCells[pos].info = Legitimate;
h->num++;
}
return h;
}
HashTable rehash(HashTable h)
{
int i;
HashTable newH = initializeTable(h->tableSize * 2);
for (i = 0; i < h->tableSize; i++)
{
if (h->theCells[i].info == Legitimate)
{
insert(h->theCells[i].element, newH);
}
}
destroyTable(h);
return newH;
}
ElementType retrive(Position p, HashTable h)
{
return h->theCells[p].element;
}
int RandInt(int i, int j)
{
int temp;
temp = (int)(i + (1.0*rand() / RAND_MAX)*(j - i));
return temp;
}
void getRandomInt(int *A, int n)
{
for (int i = 0; i < n; ++i)
{
A[i] = i + 1;
}
for (int i = 1; i < n; ++i) //std::swap(A[i], A[RandInt(0, i)]);
{
int randAdrr = RandInt(0, i);
int t = A[i];
A[i] = A[randAdrr];
A[randAdrr] = t;
}
}
main.cpp
#include<stdlib.h>
#include"hashquad.h"
#include<stdio.h>
int main()
{
getRandomInt(ranintArr, N);
HashTable h = initializeTable(10);
for (int i = 0; i < N; i++)
{
h = insert(ranintArr[i], h);
}
Position p = find(100, h);
if (isLegitimate(p, h))
{
printf("%d", retrive(p, h));
}
destroyTable(h);
return 0;
}
但是平方探测法只能消除一次的聚集问题,而对于二次聚集,那就得用到双散列了。