哈希查找

哈希查找的思想是按照某种弄规则散列(分组)

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

哈希查找适用于多次查找，查找速度是最快的

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

数组长度是几我们就对几取余，存到哈希表的对应数组下标里

但是可能会遇到哈希冲突，也就是数组里某一处已经有元素了，还要往里存

解决哈希冲突我们一般用两种方法

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);
}