分离链接法

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int ElementType;

struct SCHashListNode
{
    ElementType Element;
    int ExistNum;
    struct SCHashListNode *Next;
};

struct SCHashTable
{
    int TableSize;
    struct SCHashListNode **SCHashNodeList;
};

bool _isPrime(int Input)  
{  
    if (Input == 2 || Input == 3)  
    {  
        return true;  
    }  
    if (Input % 6 != 1 && Input % 6 != 5)  
    {  
        return false;  
    }
    int i;
    for (i = 5; i*i <= Input; i += 6)  
    {  
        if (Input % i == 0 || Input % (i+2) == 0)  
        {  
            return false;  
        }  
    }  
    return true;  
}
 
int NextPrime(int Input)
{
    bool state = _isPrime(Input);
    while(!state)
    {
        state = _isPrime(++Input);
    }
    return Input;
}

int Hash(ElementType Key,int TSize)
{
    return Key % TSize;
}

struct SCHashTable* SCHashTableInit(int TableSizeInput)
{
    struct SCHashTable *HashTable;
    int i;

    HashTable = malloc(sizeof(struct SCHashTable));
    HashTable -> TableSize = NextPrime(TableSizeInput);
    
    HashTable->SCHashNodeList = malloc(HashTable -> TableSize*sizeof(struct SCHashListNode));
    
    for(i = 0;i < HashTable -> TableSize;i ++)
    {
        HashTable->SCHashNodeList[i] = malloc(sizeof(struct SCHashListNode));
        HashTable->SCHashNodeList[i]->Next = NULL;
        HashTable->SCHashNodeList[i]->ExistNum = 0;
    }
    return HashTable;
}

void SCHashTableDelete(struct SCHashTable* HashTable)
{
    struct SCHashListNode *PtrToList;
    
    int i;
    for(i = 0;i < HashTable->TableSize;i ++)
    {
        PtrToList = HashTable->SCHashNodeList[i];
        free(PtrToList);
    }
    free(HashTable);
}

//if doesn't find,return NULL
struct SCHashListNode* SCHashListNodeFind(struct SCHashTable* HashTable,ElementType ToBeFind)
{
    struct SCHashListNode *PtrToListNode;
    struct SCHashListNode *PtrToList;
    
    PtrToList = HashTable->SCHashNodeList[Hash(ToBeFind,HashTable->TableSize)];
    PtrToListNode = PtrToList -> Next;
    
    //probably need overload operator '='
    while(PtrToListNode!=NULL && PtrToListNode->Element != ToBeFind)
    {
        PtrToListNode = PtrToListNode -> Next;
    }
    return PtrToListNode;
}

//if doesn't find,return NULL
struct SCHashListNode* _SCHashListNodeFindPre(struct SCHashTable* HashTable,ElementType ToBeFind)
{
    struct SCHashListNode *PtrToListNode;
    struct SCHashListNode *PtrToList;
    
    PtrToList = HashTable->SCHashNodeList[Hash(ToBeFind,HashTable->TableSize)];
    PtrToListNode = PtrToList;
    
    //probably need overload operator '='
    while(PtrToListNode->Next != NULL && PtrToListNode->Next->Element != ToBeFind)
    {
        PtrToListNode = PtrToListNode -> Next;
    }
    return PtrToListNode;
}

void SCHashListNodeInsert(struct SCHashTable* HashTable,ElementType ToBeInsert)
{
    struct SCHashListNode *NewCell;
    struct SCHashListNode *InsertPos;
    struct SCHashListNode *PtrToList;
    
    InsertPos = SCHashListNodeFind(HashTable,ToBeInsert);
    if(InsertPos==NULL)//not find
    {
        NewCell = malloc(sizeof(struct SCHashListNode));
        
        PtrToList = HashTable->SCHashNodeList[Hash(ToBeInsert,HashTable->TableSize)];
        NewCell -> Next = PtrToList -> Next;
        //probably need overload operator '='
        NewCell -> Element = ToBeInsert;
        NewCell -> ExistNum ++;
        PtrToList -> Next = NewCell;
    }
    else
    {
        InsertPos->ExistNum ++;
    }
}

//return the ExistNum,if not find return -1,if error return -2
int SCHashListNodeDelete(struct SCHashTable* HashTable,ElementType ToBeDelete)
{
    struct SCHashListNode *DeletePosPre;
    struct SCHashListNode *PtrToList;
    
    DeletePosPre = _SCHashListNodeFindPre(HashTable,ToBeDelete);
    if(DeletePosPre->Next==NULL)//not find
    {
        return -1;
    }
    else
    {
        if(DeletePosPre->Next->ExistNum==1)
        {
            struct SCHashListNode* TmpCell;
            TmpCell = DeletePosPre->Next;
            DeletePosPre->Next = DeletePosPre->Next->Next;
            free(TmpCell);
            
            return 0;
        }
        else
        {
            DeletePosPre->Next->ExistNum --;
            
            return DeletePosPre->Next->ExistNum;
        }
    }
    return -2;
}

int main()
{
    struct SCHashTable* HashTable = SCHashTableInit(10000);
    SCHashListNodeInsert(HashTable,23);
    SCHashListNodeInsert(HashTable,23);
    SCHashListNodeInsert(HashTable,23);
    SCHashListNodeDelete(HashTable,23);
    SCHashListNodeInsert(HashTable,47);
    SCHashListNodeInsert(HashTable,50);
    struct SCHashListNode *OutputNode = SCHashListNodeFind(HashTable,23);
    printf("%d %d
",OutputNode->Element,OutputNode->ExistNum);
    OutputNode = SCHashListNodeFind(HashTable,47);
    printf("%d %d
",OutputNode->Element,OutputNode->ExistNum);
    OutputNode = SCHashListNodeFind(HashTable,39);
    if(OutputNode == NULL)
        printf("where is my princess Hatsune Miku?
");
    SCHashTableDelete(HashTable);
    return 0;
}