写了个哈希表，底层逻辑基于结构体数组，核心结构:HashNode,结构外壳:HashTable_R,冲突处理以后会加的(QwQ)~

目前代码：

#ifndef PYIC_X
#define PYIC_X

unsigned int PYIC_Hash(unsigned int Val, unsigned int Mov) {
    unsigned int Ht[4] = { 3, 7, 2, 1 };
    unsigned int Move = (Val + Mov) % 4;
    unsigned int PrimeFactor1 = 31;
    unsigned int PrimeFactor2 = 37; // 使用另一个质数  
    unsigned int HashValue = (Val * PrimeFactor1 + Ht[Move]) % 0xFFFFFFFF;

    // 结合第二个质数  
    HashValue = (HashValue * PrimeFactor2 + (Val ^ Mov)) % 0xFFFFFFFF;

    return HashValue;
}
typedef struct HashNode__Made__PYIC_X
{
    unsigned int Val;
    unsigned int Map;
    int _Vbool;
    int _Mbool;
}HashNode;
void Insert_Hash(HashNode Table[], unsigned int Num, unsigned int Val, unsigned int Mov)
{
    unsigned int Index = PYIC_Hash(Val, Mov);
    Table[Index]._Mbool = 1;
    Table[Index].Map = Num;

    Table[Num]._Vbool = 1;
    Table[Num].Val = Val;
}
void Remove_Hash(HashNode Table[], unsigned int Val, unsigned int Mov)
{
    unsigned int Index = PYIC_Hash(Val, Mov);
    Table[Table[Index].Map]._Vbool = 0;
    Table[Table[Index].Map].Val = 0;

    Table[Index]._Mbool = 0;
    Table[Index].Map = 0;
}
int Find_Hash(HashNode Table[], unsigned Val, unsigned int Mov)
{
    unsigned int Index = PYIC_Hash(Val, Mov);
    if (Table[Index]._Mbool == 1)
        return (int)Table[Index].Map;
    else
        return -1;
}
void RemNum_Hash(HashNode Table[], unsigned Num, unsigned int Mov)
{
    unsigned int Index = PYIC_Hash(Table[Num].Val, Mov);
    Table[Index]._Mbool = 0;
    Table[Index].Map = 0;

    Table[Num]._Vbool = 0;
    Table[Num].Val = 0;
}

unsigned int GetHash(HashNode Table[], int Num)
{
    return Table[Num].Val;
}

typedef struct HashTable_R
{
    HashNode* Node_Array;
    unsigned int All;
    unsigned int Num;
}HashTable_R;
void Insert_HashR(HashTable_R* Table,int Num,int Val,int Mov)
{
    Insert_Hash(Table->Node_Array, Num, Val, Mov);
    Table->All += Val;
    Table->Num += 1;
}
void Remove_HashR(HashTable_R* Table, int Val, int Mov)
{
    Remove_Hash(Table->Node_Array, Val, Mov);
    Table->Num -= 1;
    Table->All -= Val;
}
int Find_HashR(HashTable_R* Table, int Val, int Mov)
{
    return Find_Hash(Table->Node_Array, Val, Mov);
}

#if 0
typedef struct ListNode
{
    int Val;
    struct ListNode* Next;
}ListNode;
void Insert_List(ListNode* Head, int Val)
{
    struct ListNode On {};
    while (Head->Next =!0)
    {
        Head = Head->Next;
    }
    On.Val = Val;
    On.Next = 0;
    Head->Next = &On;
}
int Find_List(ListNode* Head, int Val)
{
int i = 0;
    while (Head->Next = !0)
    {
        if (Head->Val = Val)
        {
            return i;
        }
        Head = Head->Next;
        i++;
    }
    return -1;
}
#endif
#endif

看得懂的就散吧，看不懂都留下：

-----------【代码解析】--------------------------------------------------------------------------

总体函数逻辑和上一个一样，改了哈希函数，使它更加强大，且不容易碰撞。并增加了异或操作，使其拥有了雪崩效应；

增加了外壳：HashTable_R

这里面有个指针指向一个结构体数组版的哈希表，其名为Node_Array,作用是用于套用哈希表。

All:所有值的和

Num:元素的数量

这次，每插入一个元素都会增加计数器和All,添加了新功能。

散会。