哈希查找的思想是按照某種弄規則散列(分組)

創建哈希表，可以多次利用

哈希查找適用於多次查找，查找速度是最快的

散列我們一般用求整取余法

數組長度是幾我們就對幾取余，存到哈希表的對應數組下標裏

但是可能會遇到哈希沖突，也就是數組裏某一處已經有元素了，還要往裏存

解決哈希沖突我們一般用兩種方法

1.開放地址法

　　1.1線性探測　　有沖突就放入下一個

　　1.2線性補償探測　　有沖突就向後走步長個

　　1.3線性有償再散列　　有沖突就往±1，±4，±9，±16放

　　1.4隨機補償　　生成隨機數，如果有的話再生成

2.拉鏈法

　　代碼如下

typedef struct NODE
{
    
 
int nValue;
    int xb;
    struct NODE* pNext;
}Node;


Node** CreateHX(int* arr,int length)
{
    //創建一個指針數組 
    Node** ptemp = (Node**)malloc(sizeof(Node*) * length);
    memset(ptemp,0,sizeof(Node*)*length);
    
    int j;
    for(int i=0;i<length;i++)
    {
        //求整取余 
        j = arr[i]%length;
        Node
 
* p = (Node*)malloc(sizeof(Node));
        p->nValue = arr[i];
        p->xb = i;
        p->pNext = NULL;
        //鏈表的頭添加 
        if(ptemp[j] == NULL)
        {
            ptemp[j] = p;                
        }
        else
        {
            p->pNext = ptemp[j];
            ptemp[j] 
 
= p;
        }
    }
    return ptemp;
}

int Search(Node** node,int* arr,int length,int num)
{
    //得到余數，哈希表的下標 
    int j = num%length;
    Node* ptemp = NULL;
    if(node[j])
    {
        //得到鏈表頭 
        ptemp = node[j];
        while(ptemp != NULL)
        {
            if(ptemp->nValue == num)
                return ptemp->xb;
            ptemp = ptemp->pNext;    
        }
    }
    return -1;
}

void DeleteHX(Node** pNode,int length)
{
    Node* p = NULL;
    for(int i=0;i<length;i++)
    {
        while(pNode[i])
        {
            p = pNode[i];
            pNode[i] = pNode[i]->pNext;
            free(p);
            p = NULL;
        }
    }

    free(pNode);
}

哈希查找