数据结构与算法分析-分离链接散列表的实现

#include<stdio.h>
#include<math.h>

typedef char* ElementType;
typedef unsigned int Index;
#define MinTableSize 15

struct ListNode;
typedef struct ListNode *Position;
struct HashTbl;
typedef struct HashTbl *HashTable;

HashTable InitializeTable(int TableSize);
void DestroyTable(HashTable H);
Position Find(ElementType key,HashTable H);
void Insert(ElementType key,HashTable H);
ElementType Retrieve(Position P);
void Delete(ElementType key,HashTable H);

struct ListNode
{
ElementType Element;
Position next;
};

typedef Position List;

struct HashTbl
{
int TableSize;
List *TheLists;
};

Index Hash(const char *key,int TableSize)
{
unsigned int HashVal=0;
while(*key!='\0')
{
HashVal+=*key++;
}
return HashVal%TableSize;
}

int NextPrime(int TableSize)
{
int i,j=2;
for(i=TableSize;i>0;i--)
{
while(j<sqrt(i))
{
if(i%j==0)
break;
j++;
}
if(j==sqrt(i))
break;
}
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->TheLists=malloc(sizeof(List)*H->TableSize);
if(H->TheLists==NULL)
{
FatalError("Out of space!!");
}
for(i=0;i<H->TableSize;i++)
{
//分配头节点
H->TheLists[i]=malloc(sizeof(struct ListNode));
if(H->TheLists[i]==NULL)
FatalError("Out of space!!");
else
H->TheLists[i]->next=NULL;
}
return H;
}

void DestroyTable(HashTable H)
{
int i;
for(i=0;i<H->TableSize;i++)
{
free(H->TheLists[i]);
}
free(H->TheLists);
free(H);
}

Position Find(ElementType key,HashTable H)
{
Position P;
List L;
L=H->TheLists[Hash(key,H->TableSize)];
P=L->next;
while(P!=NULL&&P->Element!=key)
P=P->next;
return P;
}

void Insert(ElementType key,HashTable H)
{
Position Pos,NewCell;
List L;
Pos=Find(key,H);
if(Pos==NULL)
{
NewCell=malloc(sizeof(struct ListNode));
if(NewCell==NULL)
{
FatalError("Out of space!!");
}
else
{
L=H->TheLists[Hash(key,H->TableSize)];
NewCell->next=L->next;
NewCell->Element=key;
L->next=NewCell;
}
}
}

ElementType Retrieve(Position P)
{
if(P==NULL)
return NULL;
else
return P->Element;
}

void Delete(ElementType key,HashTable H)
{
Position Pos,Pre;
List L;
int i;
Pos=Find(key,H);
if(Pos==NULL)
return;
else
{
L=H->TheLists[Hash(key,H->TableSize)];
for(Pre=L;pre->next!=NUll;Pre=Pre->next)
{
if(Pre->next==Pos)
{
free(Pos->Element);
free(Pos);
break;
}
}
}
}