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

#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;

            }

        }

    }

}