devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

哈希表（散列表）、哈希表闭散列(线性探测、二次探测)解决冲突、负载因子_散列表的负载因子

作者：IT小白 | 2024-06-03 09:07:34

赞

踩

散列表的负载因子
哈希概念

常规搜索：
  数据杂乱无章——->顺序查找—–>时间复杂度0(n)。
  数据有序—–>二分查找——>时间复杂度0(log(n))。
  建立二叉搜索树—–>时间复杂度0(n)（单支树）。
理想的搜索方法是：可以不经过任何比较，一次直接从表中得到要搜索的元素，如果构造一种存储结构，通过某种函数使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么查找时通过该函数可以很快的找到该元素。
当该结构中：

  • 插入元素时：根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放。
  • 搜索元素时：对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若相等，则搜索成功。

该方法即为哈希（散列）方法，哈希方法中使用的转换函数称为哈希（散列）函数，构造出来的结构称为哈希表或者散列表。
这里写图片描述
用该方法进行搜索不必进行多次关键码的比较，因此搜索速度比较快。但是哈希函数中一般会选一个最接近m（空间大小）的质数作为除数。
问题：按照上述哈希方法，向集合中插入2，会出现什么问题？？

  对于两个数据元素的关键字M,N(M!=N),但有Hash(M)=Hash(N),即不同的关键字算出了相同的哈希地址，该现象称为哈希冲突或哈希碰撞，把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。
那么如何处理哈希冲突呢？？？？

发生哈希冲突的原因：
  1. 哈希函数设置不合理
   考虑重新设计哈希函数
    哈希函数设计原则：
      ①.哈希函数的定义域必须包含需要存储的全部关键码，如果散列表有m个地址，其值域必须在0~m-1之间。
      ②.哈希函数计算出来的地址能均匀的分布在整个空间中。
      ③.哈希函数应该比较简单。
具体解决方法：

  • 闭散列：开放定值法，当发生哈希冲突时，如果哈希表未被装满，说明哈希表必然还有空位置，那么就把关键字存放到表中“下一个”空位置去。
  • 开散列：链地址法（开链法）首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一个集合，每一个子集称为一个桶，各个桶中的元素通过一个单链表链接起来。

本篇我们主要讲解闭散列：

闭散列：
  当发生哈希冲突时，如果哈希表未被装满，说明哈希表必然还有空位置，那么就把关键字存放到表中“下一个”空位置去。
  那如何寻找下一个空余位置？

1. 线性探测
  从发生冲突的位置开始，依次继续向后探测，直到有空位置。
插入时：使用哈希函数找到待插入元素在哈希表中的位置，如果该位置没有元素则直接插入，如果该位置有元素但不是待插入元素则发生哈希冲突，使用线性探测找到下一个空位置，在找空位置的路上如果遇到元素与待插入元素相同则不插入（即哈希表中不允许有相同的元素），没有遇到等找到空位置就插入。
这里写图片描述
说明： 由于哈希表里不能有相同的元素，所以删除元素时就不能随便删除元素，若直接删除极易导致哈希表中元素重复。
这里写图片描述
优点： 简单
缺陷： 一旦发生哈希冲突，所有的冲突连在一起，容易产生数据堆积。
那如何缓解呢？？
负载因子：
  散列表的负载因子定义为：α=填入表中的元素个数 / 散列表的长度。α是散列表装满程度的标志因子，由于表长是定值，α与填入表中的元素个数成正比，所以，α越大，填入表中的元素就越多，产生冲突的可能性就越大；反之，α越小，标明填入表中的元素就越少，产生冲突的可能性就越小。一般应该严格控制在0.7~0.8之间。超过0.8，查表时的不命中率按照指数曲线上升。

  1. 二次探测
      发生哈希冲突时，二次探测寻找下一个空位置的公式为：H(i)=（H(0)+i^2）^2%m
    这里写图片描述
    优点：不存在数据堆积。
    缺点： 当元素较多时需要比较很多次。

代码实现：
.h文件

#include<assert.h>
#include<malloc.h>
#include<stdlib.h>
#include<math.h>
#include<assert.h>
#include<stdio.h>
//哈希表的状态
typedef enum state
{
    EMPTY, //空
    EXIST, //存在
    DELETE,//删除
}state;

typedef int DataType;
typedef struct Elem
{
    DataType _data;
    enum state _state;
}Elem;

typedef struct Size
{
    int size; //哈希表中有效元素个数
    int del;  //哈希表被删除元素的个数
}Size;
//哈希表
typedef struct HashTable
{
    Elem *data;
    int capacity;
    Size size;
}HashTable;



//初始化哈希表
void InitHashTable(HashTable *hashtable);
//插入哈希表
void InsertHashTable(HashTable *hashtable, DataType data);
//删除哈希表
int  DeleteHashTable(HashTable *hashtable, DataType data);
//查找
int FindHashTable(HashTable *hashtable, DataType data);
//判空
int EmptyHashTable(HashTable *hashtable);
//哈希表元素个数
int SizeHashTable(HashTable *hashtable);
//打印哈希表
void print(HashTable *hashtable);
//销毁哈希表
void DestroyHashTable(HashTable *hashtable);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53

HashTable.c

#include"HashTable.h"

//素数表
#define primesize 28
unsigned long int _PrimeList[primesize] = {
    53ul, 97ul, 193ul, 389ul, 769ul,
    1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
    49157ul, 98317ul, 196613ul, 39324ul, 786433ul,
    1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
    60331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
    1610612741ul, 3221225473ul, 4294967291ul
};
//素数
int Prime(int capacity)
{
    int i = 0;
    for (i = 0; i < primesize; i++)
    {
        if ((int)_PrimeList[i] >= capacity)
        {
            return _PrimeList[i];
        }
    }
    return _PrimeList[primesize - 1];
}
//初始化哈希表
void InitHashTable(HashTable *hashtable)
{
    int i = 0;
    int capacity;
    assert(hashtable);
    //初始化容量
    capacity = 5;
    hashtable->capacity = Prime(capacity);
    //初始化data
    hashtable->data = (Elem*)malloc(hashtable->capacity*sizeof(Elem));
    if (hashtable->data == NULL)
    {
        assert(0);
        return ;
    }
    //初始化数组
    for (i = 0; i < hashtable->capacity; i++)
    {
        hashtable->data[i]._data = 0;
        hashtable->data[i]._state = EMPTY;
    }

    //初始化元素
    hashtable->size.size = 0;
    hashtable->size.del = 0;
}


//哈希函数
int HashFun(HashTable* hashtable,DataType data)
{
    assert(hashtable);
    return data % hashtable->capacity;
}
//判断是否需要扩容
Elem * ExpandCapacity(HashTable *hashtable)
{
    int i = 0;
    int addr = 0;
    int newcapacity = 0;
    int oldcapacity = hashtable->capacity;
    Elem *new = NULL;
    //扩容量
    newcapacity = Prime(hashtable->capacity);
    //开辟新空间
    new= (Elem *)malloc(newcapacity*sizeof(Elem));
    if (new == NULL)
    {
        assert(0);
        return NULL;
    }

    //初始化新空间
    for (i = 0; i < newcapacity; i++)
    {
        new[i]._data = 0;
        new[i]._state = EMPTY;
    }

    hashtable->capacity = newcapacity;
    //搬元素
    for (i = 0; i < oldcapacity; i++)
    {
        if (hashtable->data[i]._state == EXIST)
        {
            //新哈希地址
            addr = HashFun(hashtable, hashtable->data[i]._data);
            //插入新表
            while (new[addr]._state != EMPTY)
            {
#if 0
                //线性探测
                addr++;
                if (addr == hashtable->capacity)
                {
                    addr = 0;
                }
#else
                //二次探测
                //二次探测
                i++;
                addr = addr + 2 * i + 1;
                addr = addr%hashtable->capacity;
            }
#endif
            new[addr]._data=hashtable->data[i]._data;
            new[addr]._state = EXIST;
        }
    }
    hashtable->size.del = 0;
    free(hashtable->data);
    hashtable->data = new;
    return new;
}
//插入哈希表
void InsertHashTable(HashTable *hashtable, DataType data)
{
    int i = 0;
    assert(hashtable);
    //判断是否扩容，如果表中的个数超过自己的哈希因子，则需要扩容
    if ((hashtable->size.del + hashtable->size.size) * 10 / hashtable->capacity >= 7)
    {
        ExpandCapacity(hashtable);
    }
    int Add = 0;
    Add = HashFun(hashtable,data);
    while (hashtable->data[Add]._state!=EMPTY )
    {
        //如果有与data相同的结点则不插入
        if (hashtable->data[Add]._state == EXIST&&
            hashtable->data[Add]._data == data)
        {
            return;
        }
#if 0
        //线性探测
        Add++;
        if (Add == hashtable->capacity)
        {
            Add = 0;
        }
#else
        //二次探测
        i++;
        Add = Add + 2 * i + 1;
        Add = Add%hashtable->capacity;
    }
#endif
    hashtable->data[Add]._data = data;
    hashtable->data[Add]._state = EXIST;
    hashtable->size.size++;
}

//删除哈希表
int  DeleteHashTable(HashTable *hashtable, DataType data)
{
    int Add = 0;
    int i = 0;
    assert(hashtable);
    if (hashtable->size.size == 0)
    {
        //哈希表为空，无法删除
        printf("无法删除\n");
        return -1;
    }
    else
    {
        Add = HashFun(hashtable, data);
        while (hashtable->data[Add]._state != EMPTY)
        {
            if (hashtable->data[Add]._state == EXIST
                &&hashtable->data[Add]._data == data)
            {
                hashtable->data[Add]._state = DELETE;
                hashtable->size.del++;
                hashtable->size.size--;
                return 1;
            }
            else
            {
#if 0
                Add++;
                if (Add == hashtable->capacity)
                {
                    Add = 0;
                }
#else
                //二次探测
                i++;
                Add = Add + 2 * i + 1;
                Add = Add % hashtable->capacity;
#endif
            }
        }
        //没有找到元素，无法删除
        return -1;
    }
}

//查找
int FindHashTable(HashTable *hashtable, DataType data)
{
    int Add = 0;
    int i = 0;
    assert(hashtable);
    if (hashtable->size.size == 0)
    {
        printf("哈希表为空!\n");
        return -1;
    }
    else
    {
        Add = HashFun(hashtable, data);
        while (hashtable->data[Add]._state != EMPTY )
        {
            if (hashtable->data[Add]._state==EXIST
                &&hashtable->data[Add]._data == data)
            {
                return Add;
            }
#if 0
            Add++;
            if (Add == hashtable->capacity)
            {
                Add = 0;
            }
#else
            //二次探测
            i++;
            Add = Add + 2 * i + 1;
            Add = Add % hashtable->capacity;
#endif
        }
        return -1;
    }
}

//判空
int EmptyHashTable(HashTable *hashtable)
{
    assert(hashtable);
    return hashtable->size.size == 0;
}
//哈希表元素个数
int SizeHashTable(HashTable *hashtable)
{
    assert(hashtable);
    return hashtable->size.size;
}

//打印哈希表
void print(HashTable *hashtable)
{
    int i = 0;
    for (i = 0; i < hashtable->capacity; i++)
    {
        if (hashtable->data[i]._state == EMPTY)
        {
            printf("add=%d EMPTY %d\n", i,hashtable->data[i]._data);
        }
        else if (hashtable->data[i]._state == DELETE)
        {
            printf("add=%d DELETE %d\n",i, hashtable->data[i]._data);
        }
        else
        {
            printf("add=%d EXIST %d\n", i,hashtable->data[i]._data);
        }
    }
}

//销毁哈希表
void DestroyHashTable(HashTable *hashtable)
{
    assert(hashtable);
    free(hashtable->data);
    hashtable->data = NULL;
    hashtable->size.del = 0;
    hashtable->size.size = 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286

测试.c

#include"HashTable.h"


void Test()
{
    HashTable hashtable;

    //初始化哈希表
    InitHashTable(&hashtable);
    //插入哈希表
    InsertHashTable(&hashtable, 10);
    InsertHashTable(&hashtable, 3);
    InsertHashTable(&hashtable, 19);
    InsertHashTable(&hashtable, 2);
    InsertHashTable(&hashtable, 20);
    //删除哈希表
    DeleteHashTable(&hashtable, 2);


    InsertHashTable(&hashtable, 4);
    InsertHashTable(&hashtable, 6);
    InsertHashTable(&hashtable, 108);
    InsertHashTable(&hashtable, 12);
    InsertHashTable(&hashtable, 8);
    //删除哈希表
    DeleteHashTable(&hashtable, 20);
    DeleteHashTable(&hashtable, 6);

    //查找
    if (FindHashTable(&hashtable, 19)!= -1)
    {
        printf("%d的哈希地址为：%d\n", 19, FindHashTable(&hashtable, 19));
    }
    else
    {
        printf("没有找到!\n");
    }
    printf("哈希表元素个数：%d\n", SizeHashTable(&hashtable));

    //判空
    if (EmptyHashTable(&hashtable))
    { 
        printf("哈希表为空!\n");
    }
    else
    {
        printf("哈希表不为空!\n");
    }
    print(&hashtable);
    //销毁哈希表
    DestroyHashTable(&hashtable);

}
int main()
{
    Test();
    system("pause");
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59

这里写图片描述
这里写图片描述

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/666580
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号