开放定址法+平方探测法+再散列

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

typedef int ElementType;
enum KindOfEntry {Legitimate,Empty,Deleted};

struct OAHashListNode
{
    ElementType Element;
    int ExistNum;
    enum KindOfEntry State;
};

struct OAHashTable
{
    int TableSize;
    int CurrentSize;
    struct OAHashListNode *OAHashNodeList;
};

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 OAHashTable* OAHashTableInit(int TableSizeInput)
{
    struct OAHashTable *HashTable;
    int i;

    HashTable = malloc(sizeof(struct OAHashTable));
    HashTable -> TableSize = NextPrime(TableSizeInput);
    HashTable -> CurrentSize = 0;
    HashTable -> OAHashNodeList = malloc(HashTable->TableSize*sizeof(struct OAHashListNode));

    for(i = 0; i < HashTable -> TableSize; i ++)
    {
        HashTable -> OAHashNodeList[i].State = Empty;
        HashTable -> OAHashNodeList[i].ExistNum = 0;
    }
    return HashTable;
}

void OAHashTableDelete(struct OAHashTable* HashTable)
{
    free(HashTable->OAHashNodeList);
}

//if doesn't find,return a index that HashTable->OAHashNodeList[Index].State == Empty
int OAHashListNodeFind(struct OAHashTable* HashTable,ElementType ToBeFind)
{
    int Index;
    int TmpAssist = 0;

    Index = Hash(ToBeFind,HashTable->TableSize);
    //F(i) = F(i-1) + 2i - 1
    while(HashTable->OAHashNodeList[Index].State != Empty
            && HashTable->OAHashNodeList[Index].Element != ToBeFind)
    {
        Index += 2 * ++TmpAssist - 1;
        if(Index >= HashTable->TableSize)
            Index -= HashTable->TableSize;
    }
    return Index;
}

struct OAHashTable* OAHashListRehash(struct OAHashTable* HashTable)
{
    int i,OldSize,OldCurrent;
    struct OAHashListNode* OldNodes;
    struct OAHashTable* NewHashTable;
    
    OldNodes = HashTable->OAHashNodeList;
    OldSize = HashTable->TableSize;
    OldCurrent = HashTable->CurrentSize;
    
    NewHashTable = OAHashTableInit(2*OldSize);
    NewHashTable->CurrentSize = OldCurrent;
    for(i = 0;i < OldSize;i ++)
    {
        if(OldNodes[i].State == Legitimate)
        {
            int Index = OAHashListNodeFind(NewHashTable,OldNodes[i].Element);
        //    printf("%d
",Index);
            NewHashTable->OAHashNodeList[Index].Element = OldNodes[i].Element;
            NewHashTable->OAHashNodeList[Index].ExistNum = OldNodes[i].ExistNum;
            NewHashTable->OAHashNodeList[Index].State = OldNodes[i].State;
        }
    }
    OAHashTableDelete(HashTable);
    return NewHashTable;
}

struct OAHashTable* OAHashListNodeInsert(struct OAHashTable* HashTable,ElementType ToBeInsert)
{
    int Index;

    Index = OAHashListNodeFind(HashTable,ToBeInsert);

    HashTable->OAHashNodeList[Index].State = Legitimate;
    HashTable->OAHashNodeList[Index].Element = ToBeInsert;
    HashTable->OAHashNodeList[Index].ExistNum ++;
    HashTable->CurrentSize ++;
    
    if(2*HashTable->CurrentSize >= HashTable->TableSize)
    {
        struct OAHashTable* NewHashTable = OAHashListRehash(HashTable);
        HashTable = NewHashTable;
        return NewHashTable;
    }
    return HashTable;
}

//return the ExistNum,if not find return -1,if error return -2
int OAHashListNodeDelete(struct OAHashTable* HashTable,ElementType ToBeDelete)
{
    int Index;
    
    Index = OAHashListNodeFind(HashTable,ToBeDelete);
    if(HashTable->OAHashNodeList[Index].State == Empty)
    {
        return -1;
    }
    else
    {
        HashTable->OAHashNodeList[Index].State = Deleted;
        HashTable->OAHashNodeList[Index].ExistNum --;
        return HashTable->OAHashNodeList[Index].ExistNum;
    }
    
    return -2;
}

int main()
{
    struct OAHashTable* HashTable = OAHashTableInit(5);
    
    HashTable = OAHashListNodeInsert(HashTable,23);
    HashTable = OAHashListNodeInsert(HashTable,23);
    HashTable = OAHashListNodeInsert(HashTable,23);
    OAHashListNodeDelete(HashTable,23);
    HashTable = OAHashListNodeInsert(HashTable,47);
    HashTable = OAHashListNodeInsert(HashTable,50);
    
    int OutputIndex = OAHashListNodeFind(HashTable,23);
    printf("%d %d
",HashTable->OAHashNodeList[OutputIndex].Element,HashTable->OAHashNodeList[OutputIndex].ExistNum);
    OutputIndex = OAHashListNodeFind(HashTable,47);
    printf("%d %d
",HashTable->OAHashNodeList[OutputIndex].Element,HashTable->OAHashNodeList[OutputIndex].ExistNum);
    OutputIndex = OAHashListNodeFind(HashTable,39);

    if(HashTable->OAHashNodeList[OutputIndex].State == Empty)
        printf("where is my princess Hatsune Miku?
");
    OAHashTableDelete(HashTable);
    return 0;
}