散列表

一、基本概念

关键字的全域为集合U，待散列的关键字集合为K，散列表的存储需求为O(K)，同时针对平均情况的查找时间为O(1)。关键字k被存放在槽h(k)中，即利用散列函数h，由关键字k计算出槽的位置，h将U映射到散列表T[0...m1]的槽位上。

冲突：两个关键字可能映射到同一个槽中。

解决冲突：链接法、开放寻址法

二、通过链接法解决冲突

把散列到同一槽中的所有元素都放在一个链表中，如下图所示。

 

 

/* 通过链接法解决冲突的散列表
   链接链表，使用双向、非循环、非排序方式
*/
#include <stdio.h>
#include <stdlib.h>

#define HASH_SIZE 10
#define ARRAY_SIZE 15

typedef struct object {
    int key;
    struct object *prev,*next;
}object_s;

typedef struct chainedhash {
    object_s *ptable[HASH_SIZE];
}chainedhash_s;

//函数声明
void chained_hash_init(chainedhash_s *phash);
void chained_hash_insert(chainedhash_s *phash, int key);
object_s *chained_hash_search(chainedhash_s *phash, int key);
void chained_hash_delete(chainedhash_s *phash, object_s *pobj);
void chained_hash_print(chainedhash_s *phash);
int hash_function(int key);

int main(void)
{
    chainedhash_s hash;
    int index;    
        
    chained_hash_init(&hash);
    
    for(index=0;index<ARRAY_SIZE; index++) {
         chained_hash_insert(&hash, index);
    }
    
    chained_hash_print(&hash);
    return 0;
}

void chained_hash_init(chainedhash_s *phash)
{
    int i;
    for(i=0; i<HASH_SIZE; i++)
        phash->ptable[i] = NULL;
}

void chained_hash_insert(chainedhash_s *phash, int key)
{
    object_s *pobj;
    int index;
    
    pobj = (object_s*)malloc(sizeof(object_s));
    pobj->key = key;
    index = hash_function(key);
    
    // 从链表头插入
    if(phash->ptable[index] != NULL)
        phash->ptable[index]->prev = pobj;
    pobj->prev = NULL;
    pobj->next = phash->ptable[index];
    phash->ptable[index] = pobj;
    
    return;
}

object_s *chained_hash_search(chainedhash_s *phash, int key)
{
    int index;
    object_s *pobj;
    
    index = hash_function(key);
    for(pobj=phash->ptable[index]; pobj!=NULL; pobj=pobj->next) {
        if(pobj->key == key)
            return pobj;
    }
        
    return NULL;
}

void chained_hash_delete(chainedhash_s *phash, object_s *pobj)
{
    int index;
    index = hash_function(pobj->key);
    
    if(phash->ptable[index] == pobj) {
        phash->ptable[index] = pobj->next;
        if(pobj->next != NULL)
            pobj->next->prev = NULL;
    } else {
        pobj->prev->next = pobj->next;
        if(pobj->next != NULL)
            pobj->next->prev = pobj->prev;
    }
    free(pobj);
}

void chained_hash_print(chainedhash_s *phash)
{
    int index;
    object_s *pobj;
    
    for(index=0; index<HASH_SIZE; index++) {
        printf("%d:",index);
        for(pobj=phash->ptable[index]; pobj!=NULL; pobj=pobj->next) {
            printf("%d ",pobj->key);
        }
        printf("\n");
    }
}

int hash_function(int key)
{
    return key%10;
}

 三、开放寻址法解决冲突

在开放寻址法中，当要插入一个元素时，可以连续地检查（或称探查）散列表的各项，直到找到一个空槽来放置待插入的关键字时为止。在必须删除关键字的应用中，往往采用链表法来解决碰撞。若采用一致散列，则search、insert时间复杂度都为O(1)

探查序列有三种

1.线性探查。 h(k,i)=(h'(k) + i) mod m, i=0,1,...,m-1 ；m种不同的探查序列

2.二次探查。 h(k,i) = (h'(k) + c1*i + c*i^2) mod m ； m种不同的探查序列

3.双重散列。h(k,i) = (h1(k) + i*h2*k)) mod m ； m^2种不同的探查序列

 

// 散列表，使用开发寻址法（线性探测）解决冲突
#include<stdio.h>

#define HASH_SIZE 10
#define ARRAY_SIZE 5
#define FAIL -1

int hashtable[HASH_SIZE];

// 函数声明
int insert_hash(int hasht[], int key);
int search_hash(int hasht[], int key);
void init_hash(int hasht[]);
int hash_function(int key, int i);

int main(void)
{
    int array[ARRAY_SIZE]={3,13,23,4,28};
    int i;
    
    init_hash(hashtable);
    
    for(i=0;i<ARRAY_SIZE;i++)
        insert_hash(hashtable, array[i]);
    
    for(i=0; i<HASH_SIZE; i++)
        printf("[%d][%d]\n",i,hashtable[i]);
}

int insert_hash(int hasht[], int key)
{
    int i,j;

    for(i=0;i<HASH_SIZE;i++) {
        j=hash_function(key, i);
        if(hasht[j] == -1) {
            hasht[j]=key;
            return j;
        }
    }
    printf("hash table overflow\n");
    return FAIL;
}

int search_hash(int hasht[], int key)
{
    int i,j;
    
    for(i=0; i<HASH_SIZE; i++) {
        j=hash_function(key, i);
        if(hasht[j] == key) {
            return j;
        }
        if(-1 == hasht[j])
            break;
    }
    
    return FAIL;
}

void init_hash(int hasht[])
{
    int i;
    for(i=0; i<HASH_SIZE; i++)
        hasht[i]=-1;
}

int hash_function(int key, int i)
{
    return (key%HASH_SIZE+i)%HASH_SIZE;
}

测试结果如下：