哈希表-数据结构(C语言)

哈希表

什么是哈希表

我们在网站上注册账号时,当填好用户名后,系统都会判断用户名是否已被使用,如果已被使用,系统就会提示该用户名已被注册。那么系统是如何检测用户名是否被使用的呢?我们能想到的最简单的方法就是逐个比较,但是如果用户名有很多,查找效率就显得很低。还有一种方法就是把用户名按字典序排序进行二分查找,这个方法的效率的确是高了很多,可是前提是用户名是有序的,而有些时候我们并不能将用户名进行排序。那么还有没有更好的方法呢?

我们可以用 哈希表 来解决这个问题。哈希表又叫散列表,关键值通过哈希函数映射到数组上,查找时通过关键值直接访问数组。在上面的例子里,我们将用户名通过哈希函数映射成一个整数,也就是数组的存储位置,在检测时用同样方法计算出存储位置,如果位置上已有元素则表示用户名已经被注册。
哈希函数指的是关键值和存储位置建立的对应关系,查找时只要根据这个关系就能找到目标位置。一般我们只要通过一次查找就能找到目标位置,但有些关键字需要多次比较和查找才能找到,这是为什么呢?因为哈希表里,可能存在关键字不同但是哈希地址相同的情况,也就是产生了冲突。一般情况下,冲突是不可避免的,因为关键字集合往往比哈希地址集合大很多。
哈希表-数据结构(C语言)_第1张图片
要提高哈希表的查找效率,关键在于合理的构造哈希函数和优秀的解决冲突的方法。哈希函数的构造方法有很多种,我们应该如何构造优秀的哈希函数来减少冲突呢?如果发生了冲突,我们该如何处理冲突,减少比较次数提高查找效率呢?

创建哈希表

  1. 这一课我们来学习如何创建哈希表。首先我们来定义哈希表结构体HashTable
  2. 接下来我们来定义两个变量,一个是char 类型的二维指针变量 elem, 用来存储前面问题里的用户名,还有一个是int 类型的变量 size, size 表示哈希表的容量。
  3. 接下来我们来实现结构体 HashTable 的初始化函数init , 函数只有一个HashTable 类型的参数h.
void init(HashTable *h) {
	
}

我们先把函数定义写好,稍后再来实现。
4. 我们在初始化函数里完成以下两个步骤: 将哈希表 h 的 size 设置为 1000, 表示哈希表的长度,然后给二维指针变量 elem 动态分配 size 个 char * 乐星的内存。
5. 接下来我们给每个元素动态分配 100 个char 类型的内存, 之后赋上初值。
由于元素都是字符串,这里我们写个for 循环,用变量i 从 0 循环到不小于 哈希表 h 的 size 时退出,把每个元素都赋为空。 在后面哈希表的查找中,我们需要判断该位置上是否已有字符串。
6. 这样我们就把结构体HashTable 的初始化函数写完了,那么现在我们在主函数里创建一个HashTable 的指针变量hashtable, 并给它分配HashTable 类型的内存。 然后调用初始化函数 init 完成对哈希表的初始化。
7. 同样,我们还需要构造一个函数 clear 来释放程序运行过程中占用的内存空间。
我们先在主函数之前把函数定义写好,函数没有返回值,参数为一个 HashTable 类型的指针变量h.
8. 在clear 函数中,我们同样使用for 循环,用变量 i 从 0 循环到不小于哈希表 h 的size 时 退出来遍历所有元素。 这一步我们先把循环的条件写好。
9. 在循环中,如果哈希表中某一个元素不为空,则使用free 将它释放。
10. 循环结束后,我们还要释放 h->elem 和 指针 h 所指向的内存空间。
11. 最后,在程序结束后前吗,我们在主函数中调用 clear 函数。

#include 
#include 
#include 

// 请在下面实现哈希表结构体 HashTable

typedef struct HashTable {
    char **elem;
    int  size;
} HashTable;


// 请在下面实现初始化函数 init
void init(HashTable  *h) {
    h->size = 1000;
    h->elem =  (char **)malloc(sizeof(char *) * h->size);
    for (int i = 0; i < h->size; i++) {
        h->elem[i] = NULL;
    }
}

void clear (HashTable *h) {
    //   变量i 从 0 循环到不小于哈希表h 的 size 时 退出遍历所有的元素 
    for(int i = 0; i < h->size; ++i) {
        if(h->elem[i] != NULL){
            free(h->elem[i]);
        }
    }
    free(h->elem);
    free(h);
}

int main() {
    // 创建一盒HashTable 的指针变量 hashtable  并分配HashTable  累心的内存,  
    
    HashTable  *hashtable = (HashTable *)malloc(sizeof(HashTable));
    init(hashtable);
    clear(hashtable);
    return 0;
}

哈希函数的构造方法

通过哈希表的阅读课,我们了解到哈希函数的优劣直接影响到哈希表查找效率,优秀的哈希函数可以减少冲突的发生。哈希表里的元素可以是不同类型的,也可以是不同规律的,所以不同情况下哈希函数的设计也是不同的。常见的哈希函数构造方法有哪些呢?

直接寻址法

即取关键字的值或者关键字的某个函数变换值,线性的映射到存储地址上。如果关键字的数量和跨度不是很大,直接寻址法是最简单最有效的构造方法了,并且还可以避免冲突。但是如果关键字的数量和跨度很大的话,这种方法就用不了了,例如有 n 个关键字,值最小的为 0,最大的为 \ 1 0 10 10^{10} 1010 ,这种情况下就不能用直接寻址法了,因为没有足够的空间可用来存储。

除留余数法

我们将关键字对整数 \ p p 取的余数直接做为存储地址,整数 p 一般取小于等于哈希表长度 \ size size 的最大质数,如果关键字不是整数,比如是一个字符串,可以先将其做个转换,然后再对 p 取余。选择优秀的 p 可以减少冲突的发生。
其他的构造方法还有分析数字法,随机数法等等。

设计哈希函数没有统一的方法,同一个哈希函数不一定能适用所有问题,其产生的影响也是不一样的。但哈希函数的设计又是至关重要的,那么我们该如何设计呢?一般来说,设计哈希函数时要达到两个要求:计算简单,计算复杂的哈希函数会增加查询的时间;关键字尽可能地均分到存储地址上,这样可以减少冲突。

构造哈希函数

  1. 这一课我们来学习构造哈希函数,通过之前的课程学习,我们了解到构造哈希函数的两个要求:计算方便快捷,映射的存储地址可能均匀。
    这里我们的元素是字符串,我们先来看看经典的字符串哈希函数都有那些。
    经典的字符串哈希函数有很多,例如BKDRHash、APHash、DJBHash, JSHash、RSHash等等。 未来方便理解,我们先介绍一种简单的字符串哈希函数。
    首先,我们来定义一个返回值为 int 类型的哈希函数 hash , 函数有两个参数, 一个是 HashTable 类型的指针变量h, 另一个参数是char 类型的数组value , 这咯我们定义好 哈希函数 hash 即可,稍后再来实现。
  2. 接下来我们定义一个int 类型的变量code, 并赋初始值为0。变量code 用来记录字符串value 哈希值,也就是对应的存储位置。
  3. 接下来我们循环一遍 字符串 value, 这里我们用size _t 类型的变量i 从 0 开始 循环到不小于字符串时退出。
    我们可以使用strlen 函数 来求字符串 长度。需要注意的是,这里的变量i 不能用 int 类型,而应该用 size_t 类型, 因为字符串是char[] 类型,如果用int 会有警告。for 循环记得带上花括号。
  4. 接下来我们来计算 code .
    我们知道有符号的字符范围是从 - 128 到 127 , 也就一共有 256 种。为了减少冲突,我们可以使用这种构造方法;先让当前的code 值乘以 256, 然后加上
    第 i 个字符的值,因为字符可能会出现负值, 所以我们最后再加上128. 为了防止数据过大导致的数据溢出,我们把相加的结果再对哈希表的长度size 取余,这样我们就得到了新的哈希值 code.
    这样的构造方法 可以减少冲突的发生,但这不是唯一的构造方法。
  5. 这样我们计算出了 字符串 value 的哈希值,找到了字符串 value 对应的存储位置。在函数最后,我们把结果 code 做为返回值返回。
#include 
#include 
#include 

typedef struct HashTable {
   char **elem;
   int size;
} HashTable;

void init(HashTable *h);
int hash(HashTable *h, char value[]);

void init(HashTable *h) {
   h->size = 2000;
   h->elem = (char **)malloc(sizeof(char *) * h->size);
   for (int i = 0; i < h->size; i++) {
       h->elem[i] = NULL;
   }
}

// 请在下面实现构造哈希函数函数 hash
// 接下来 我们来定义一个 int 类型的变量 code,  并赋初始值为 0. 变量code  用来记录字符串 value 的哈希值,也就是对应的存储位置。

int hash(HashTable *h, char value[]) {
   int code  = 0;
   //  接下来我们循环一遍 字符串 value,  这里 我们用 size_t  类型的变量 i  从 0 开始 循环 到不小于字符串 长度时 退出.
   // 
   for(size_t  i = 0;  i < strlen(value); i++) {
       code = (code * 256 + value[i] + 128)  % h ->size;
   }
   
   return code;
}

void clear(HashTable *h) {
   for (int i = 0; i < h->size; ++i) {
       if (h->elem[i] != NULL) {
           free(h->elem[i]);
       }
   }
   free(h->elem);
   free(h);
}

int main() {
   HashTable *hashtable = (HashTable*)malloc(sizeof(HashTable));
   init(hashtable);
   clear(hashtable);
   return 0;
}

处理冲突的方法

通过前面的课程,我们了解到可以通过构造优秀的哈希函数来减少冲突,但是一般情况下冲突是不可避免的,那么我们该怎么处理冲突呢?前面的课程提到了解决冲突的方法也会影响哈希表的查找效率,因此选择一个优秀的方法来处理冲突显得尤为重要,那么常见的处理冲突的方法有哪些呢?

开放地址法 ,如果发生冲突,那么就使用某种策略寻找下一存储地址,直到找到一个不冲突的地址或者找到关键字,否则一直按这种策略继续寻找。如果冲突次数达到了上限则终止程序,表示关键字不存在哈希表里。一般常见的策略有这么几种:

1. 线性探测法,如果当前的冲突位置为 $d$,那么接下来几个探测地址为 $d + 1$,$d + 2$,$d + 3$ 等,也就是从冲突地址往后面一个一个探测;
2. 线性补偿探测法,它形成的探测地址为 $d + m$,$d + 2 \times m$,$d + 3 \times m$ 等,与线性探测法不同,这里的查找单位不是 $1$,而是 $m$,为了能遍历到哈希表里所有位置,我们设置 $m$ 和表长 $size$ 互质;
3. 随机探测法,这种方法和前两种方法类似,这里的查找单位不是一个固定值,而是一个随机序列。
4. 二次探测法,它形成的探测地址为 $d + 1^2$,$d - 1^2$,$d + 2^2$,$d - 2^2$ 等,这种方法在冲突位置左右跳跃着寻找探测地址。
     开放地址法计算简单快捷,处理起来方便,但是也存在不少缺点。线性探测法容易形成“堆聚”的情况,即很多记录就连在一块,而且一旦形成“堆聚”,记录会越聚越多。另外,开放地址法都有一个缺点,删除操作显得十分复杂,我们不能直接删除关键字所在的记录,否则在查找删除位置后面的元素时,可能会出现找不到的情况,因为删除位置上已经成了空地址,查找到这里时会终止查找。

链地址法 ,该方法将所有哈希地址相同的结点构成一个单链表,单链表的头结点存在哈希数组里。链地址法常出现在经常插入和删除的情况下。
相比开放地址法,链地址法有以下优点:不会出现“堆聚”现象,哈希地址不同的关键字不会发生冲突;不需要重建哈希表,在开放地址法中,如果哈希表里存满关键字了就需要扩充哈希表然后重建哈希表,而在链地址法里,因为结点都是动态申请的,所以不会出现哈希表里存满关键字的情况;相比开放地址法,关键字删除更方便,只需要找到指定结点,删除该结点即可。

开放地址法和链地址法各有千秋,适用于不同情况。当关键字规模少的时候,开放地址法比链地址法更节省空间,因为用链地址法可能会存在哈希数组出现大量空地址的情况,而在关键字规模大的情况下,链地址法就比开放地址法更节省空间,链表产生的指针域可以忽略不计,关键字多,哈希数组里产生的空地址就少了。

冲突的解决

我们知道在哈希表中,冲突是不可避免的,通过前面的学习我们了解到了几个处理冲突的方法。在接下来的课程里,我们学习在代码中实现开放地址法,然后向哈希表中插入一些元素。在此之前,我们还是先了解一下相关操作的算法流程。
通过前面的学习,我们了解了开放地址法有线性探测法、线性补偿探测法、随机探测法、二次探测法等等策略,他们的区别在于发生冲突时寻找下一个地址的方法不同。我们将实现的是用线性探测法来解决冲突。
线性探测法查找哈希冲突的算法流程如下:

1. 用哈希函数找到字符串 S 的初始位置,初始化冲突次数。
2. 从当前位置往后查找,找到第一个未发生冲突的位置 K(当前位置上如果存储的字符串不是 S 即视为发生冲突)。查找过程中记录发生冲突的次数 T,如果 T 大于等于表长,则结束算法,表示查找失败。
3. 如果位置 K 上的元素就是所查找的字符串,表示查找成功,否则表示查找失败。

现在我们已经设计了一个线性探测法来查找冲突,我们可以在元素插入哈希表中时调用这个方法去获知冲突情况。
程序执行时,如果当前的元素已经存在哈希表中了,就直接返回一个值结束这次插入操作。除此之外,我们规定,当冲突次数小于表长的一半时,我们就可以把字符串插入到哈希表中。而如果发生冲突次数大于表长的一半时,就需要调用重建函数去重建哈希表了,因为我们认为哈希表已经发生了“堆聚”现象,这种情况下我们要扩大哈希表的容量,提高查找和插入的效率。
同学们可能还记得我们在顺序表中曾经使用过的扩容操作,事实上,哈希表的重建操作和顺序表的扩容很类似。
哈希表重建操作的算法流程如下:

1. 开辟一段和当前哈希表等大的临时存储空间。
2. 将原哈希表里的关键字一一复制到临时数组里。
3. 申请一个大小是现在两倍的新的存储空间,释放原空间。
4. 将新空间里的存储地址初始化。
5. 将关键字从临时数组复制到新的空间,释放临时空间。

这样我们就完成了查找冲突,插入关键字,重建哈希表这一系列的操作,真正实现了一个完整的哈希表。

开放地址法

  1. 为了帮助同学理解哈希冲突,这一课我们来开放地址发的线性探测法解决哈希冲突,也就是哈希的查到函数。
  2. 一开始我们先在主函数前定义下哈希查找函数search , search 是一个返回值为 int 类型,分别有以下四个参数的函数;第一个是HashTable 类型的指针参数h; 第二个参数是char 数组 value; 第三个是 int 类型的指针参数 pos; 第四个是int 类型的指针参数 times. 后两个是因为我们需要记录函数执行结束后pos 和 times 的 值。
    value 表示要查找的字符串,pos 表示哈希表里可以插入 value 的位置, times 记录冲突的次数。z
  3. 接下来我们就一步步写全search 函数。首先我们要给指针变量pos 和 times 赋个初始值。pos 记录的是待插入的位置,那么初始值就等value 的哈希值,我们前面已经把哈希函数 hash 写好了,这里就可以调用 hash 求得哈希值。times 记录得是冲突次数,那么初始没有发生冲突,结果为0.
  4. 接下来我们就要循环查找 value 可以插入得位置
    我们来分析下,考虑这几种情况: 如果当前位置pos 为 空地址则表示 我们可以把value 插入到 这里; 如果pos 上已有 关键字,并且关键字就是value, 说明value 已经插入到哈希表里了; 如果pos 上已有关键字,并且关键字不是value, 说明发生冲突了 需要找一下地址。
    我们可以看到前两种情况都是终止条件,第三种情况是循环条件,所以我们可以用第三种情况下写while 循环,循环需要满足两个条件;当前位置上不为空,且不能和关键字value 相等。
  5. 如果当前位置上已经有元素,并且又不是关键字value , 则说明已经发生了冲突, 那么首先我们让记录冲突次数得指针变量 times 加 1. 这一步我们只要完成这样一个操作。
  6. 发生冲突后,我们需要找一下存储地址,首先我们要满足冲突次数 *times 要 小于 哈希表 h 的长度 size, 否则我们认为哈希表已经填满关键字了,没有空余的地址可以i存储。这一步我们只要把条件写好即可,if 语句记得协商花括号。
  7. 当满足存储条件后,我们就用开发地址法的线性探测法来找一个地址。线性探测法就是从当前位置 *pos 开始, 一个一个往后找。那么 *pos 就等于 *ops + 1, 加完后记得对哈希表h 的 size 取余,因此结果可能会超出数组长度, 如果超了就该从数组 第 0 位开始继续寻找。
  8. 这样我们就让 pos 等于 其下一个地址了。现在我们来考虑一个问题, 如果time 不小于哈希表 h 的size 怎么办》 也就是 说哈希表数组里已经没有多余的存储地址栏, 那么就返回0 来 结束函数,表示查找失败。
    这里我们跟着 if 条件写上 else 即可, 还是一样,记得写上花括号。
  9. 这样我们就把 whle 循环写完了,也就是我们已经找到了value 可以插入的位置或者 我们已经在哈希表里找到了 value.
    如果当前位置不为空,则关键字是value, 那我们返回1, 表示我们 已经找到value.
  10. 我们刚刚已经写了如果当前位置的关键字是 value 的情况,如果不是的话,那么就返回0,表示哈希表里没有关键字value, 而当前位置上正是 value 可以插入的位置。
#include 
#include 
#include 

typedef struct HashTable {
    char **elem;
    int size;
} HashTable;

void init(HashTable *h);
int hash(HashTable *h, char value[]);
int search(HashTable *h, char value[], int *pos, int *times);

void init(HashTable *h) {
    h->size = 2000;
    h->elem = (char **)malloc(sizeof(char *) * h->size);
    for (int i = 0; i < h->size; i++) {
        h->elem[i] = NULL;
    }
}

int hash(HashTable *h, char value[]) {
    int code = 0;
    for (size_t i = 0; i < strlen(value); i++) {
        code = (code * 256 + value[i] + 128) % h->size;
    }
    return code;
}

// 请在下面实现查找函数 search
int search(HashTable *h, char value[], int *pos, int  *times){
    //  给指针变量pos 和 times  赋个初始值 
    *pos =  hash(h, value);
    *times = 0;
    //  循环条件 需要满足两个条件, 但钱位置上不为空, 且不能和关键字value   相等 
    while (h->elem[*pos] != NULL && strcmp(h->elem[*pos], value)  != 0) {
         // 指针变量加 1 的情况 
        (*times)++;
        if (*times < h->size) {
            
            *pos  = (*pos + 1) % h->size;
            
        } else {
            
            return 0;
        }
    
        
    }
    
     //  如果当前位置不为空, 且关键字是value, 则我们就返回1, 表示我们已经找到value了。
    if(h->elem[*pos] != NULL && strcmp(h->elem[*pos], value) == 0) {
            return 1;
     } else {
        return 0;
    }
    
}


void clear(HashTable *h) {
    for (int i = 0; i < h->size; ++i) {
        if (h->elem[i] != NULL) {
            free(h->elem[i]);
        }
    }
    free(h->elem);
    free(h);
}

int main() {
    HashTable *hashtable = (HashTable*)malloc(sizeof(HashTable));
    init(hashtable);
    clear(hashtable);
    return 0;
}

你可能感兴趣的:(数据结构,数据结构,c语言,哈希表)