哈希表与哈希扩容

已于 2024-06-09 09:53:29 修改
阅读量412 收藏 6
点赞数 5
分类专栏： 算法 文章标签： 哈希算法 散列表 数据结构 python 算法
于 2024-06-09 09:25:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ma_no_lo/article/details/139553067
版权

一，哈希表

哈希表简单的理解：在记录的存储位置和它的关键字之间建立一个确定的对应关系f，使每个关键字和结构中一个唯一的存储位置相对应。 

哈希表基于数组的，正因为数组创建后难于扩展某些哈希表被基本填满时，性能下降得非常严重，所以程序虽必须要清楚表中将要存储多少数据（或者准备好定期地把数据转移到更大的哈希表中，这是个费时的过程）

如何定位数据存储的位置呢？

h(key) = key % size

1.线性哈希表

线性哈希表可以认为就是数组，不过他对数据的存储方式不如线性表一般按顺序来，他是通过某种算法来计算得到数据下标值的。可以想象如果数据比较多，那么重下标的情况会很多，所以就有了哈希冲突。

代码实现

class Array():
    def __init__(self,size):
        self.__size = size
        self.__item = [None]*size
        self.__length = 0

    def __setitem__(self,key,value):
        self.__item[key] = value
        self.__length += 1

    def __getitem__(self, index):
        return self.__item[index]

    def __len__(self):
        return self.__length

    def __iter__(self):
        for value in self.__item:
            yield value

class Slot():
    def __init__(self,key,value):
        self.key = key
        self.value = value

    def __str__(self):
        return 'key:{}  value:{}'.format(self.key,self.value)


class HashTable():
    def __init__(self):
        self.size = 4
        self.items = Array(self.size)



    def find_index_to_insert(self,key):
        index = self.get_index(key)
        if self.items[index] == None:
            return index
        else:
            while self.items[index] is not None:
                if self.items[index].key == key:
                    return index
                else:
                    index = (5*index+1) % self.size
            return index

    def find_key(self,key):
        index = self.get_index(key)
        if self.items[index] == None:
            return None
        else:
            while self.items is not None:
                if key == self.items[index].key:
                    return index
                else:
                    index = (5*index+1) % self.size
            return None


    def get_index(self,key):
        return hash(key) % self.size

    def put(self, key, value):
        s = Slot(key, value)
        index = self.find_index_to_insert(key)
        self.items[index] = s


    def get(self,key):
        index = self.get_index(key)
        return self.items[index]


if __name__ == '__main__':
    h = HashTable()
    h.put('name','L')
    h.put('sex','M')
    h.put('age','18')
    h.put('occupation','general')
    print(h.get('name'))
    print(h.get('sex'))
    print(h.get('age'))
    print(h.get('occupation'))

2.链式哈希表

链式哈希表可以认为是数组，不过数组内的元素是链表，有种线性表嵌套链式表的既视感，者带来的好处就多了：不仅拥有了更好的空间利用率，同时解决了哈希冲突的问题：即使出现重下标的情况，我们也可以顺着往下加，之后顺着表一个一个找就可以了。

当然对链表的处理也可以改成双向链表，不过感觉没太大必要。 

代码实现

class Array():
    def __init__(self,size):
        self.__size = size
        self.__item = [None]*size
        self.__length = 0

    def __setitem__(self,key,value):
        self.__item[key] = value
        self.__length += 1

    def __getitem__(self, index):
        return self.__item[index]

    def __len__(self):
        return self.__length

    def __iter__(self):
        for value in self.__item:
            yield value

class Slot():
    def __init__(self,key,value,next=None):
        self.key = key
        self.value = value
        self.next = next

    def __str__(self):
        return 'key:{}  value:{}'.format(self.key,self.value)


class HashTable():
    def __init__(self):
        self.size = 4
        self.items = Array(self.size)


    def get_index(self,key):
        return hash(key) % self.size

    def put(self, key, value):
        s = Slot(key, value)
        index = self.get_index(key)
        if self.items[index] == None:
            self.items[index] = s
        else:
            if self.items[index].key == key:
                self.items[index].value = value
            else:
                temp = self.items[index]
                temp_next = self.items[index].next
                while temp_next is not None:
                    if temp_next.key == key:
                        temp_next.value = value
                        return
                    else:
                        temp = temp_next
                        temp_next = temp.next
                temp.next = s


    def get(self,key):
        index = self.get_index(key)
        if self.items[index]:
            if self.items[index].key == key:
                return self.items[index]
            else:
                temp_next = self.items[index].next
                while temp_next is not None:
                    if temp_next.key == key:
                        return temp_next
                    else:
                        temp_next = temp_next.next
                return None

if __name__ == '__main__':
    h = HashTable()
    h.put('name','L')
    h.put('sex','M')
    h.put('age','18')
    h.put('occupation','general')
    print(h.get('name'))
    print(h.get('sex'))
    print(h.get('age'))
    print(h.get('occupation'))

二，哈希扩容

装载因子(load factor)

如果继续往我们的哈希表里塞东西会发生什么？空间不够用。这里我们定义一个负载因子的概念(load factor)，其实很简单，就是已经使用的槽数比哈希表大小。 比如我们上边的例子插入了 8 个元素，哈希表总大小是 13， 它的 load factor 就是 $ 8/13 \approx 0.62 $。当我们继续往哈希表插入数据的时候，很快就不够用了。 通常当负载因子开始超过 0.8 的时候，就要新开辟空间并且重新进行散列了。

重哈希(Rehashing)

当负载因子超过 0.8 的时候，需要进行 rehashing 操作了。步骤就是重新开辟一块新的空间，开多大呢？感兴趣的话可以看下 cpython 的 dictobject.c 文件然后搜索 GROWTH_RATE 这个关键字，你会发现不同版本的 cpython 使用了不同的策略。python3.3 的策略是扩大为已经使用的槽数目的两倍。开辟了新空间以后，会把原来哈希表里 不为空槽的数据重新插入到新的哈希表里，插入方式和之前一样。这就是 rehashing 操作。

代码实现

class Array():
    def __init__(self,size):
        self.__size = size
        self.__item = [None]*size
        self.__length = 0

    def __setitem__(self,key,value):
        self.__item[key] = value
        self.__length += 1

    def __getitem__(self, index):
        return self.__item[index]

    def __len__(self):
        return self.__length

    def __iter__(self):
        for value in self.__item:
            yield value

class Slot():
    def __init__(self,key,value):
        self.key = key
        self.value = value

    def __str__(self):
        return 'key:{}  value:{}'.format(self.key,self.value)


class HashTable():
    def __init__(self):
        self.size = 4
        self.length = 0
        self.items = Array(self.size)



    def find_index_to_insert(self,key):
        index = self.get_index(key)
        if self.items[index] == None:
            return index
        else:
            while self.items[index] is not None:
                if self.items[index].key == key:
                    return index
                else:
                    index = (5*index+1) % self.size
            return index

    def find_key(self,key):
        index = self.get_index(key)
        if self.items[index] == None:
            return None
        else:
            while self.items is not None:
                if key == self.items[index].key:
                    return index
                else:
                    index = (5*index+1) % self.size
            return None


    def get_index(self,key):
        return hash(key) % self.size

    def put(self, key, value):
        s = Slot(key, value)
        index = self.find_index_to_insert(key)
        self.items[index] = s
        self.length += 1
        if self.load_factor():
            self.rehashing()


    def load_factor(self):
        return self.length / float(self.size) > 0.8

    def rehashing(self):
        self.length = 0
        old = self.items
        self.size = self.size << 1
        self.items = Array(self.size)
        for s in old:
            if s:
                key = s.key
                index = self.find_index_to_insert(key)
                self.items[index] = s
                self.length += 1

    def get(self,key):
        index = self.get_index(key)
        return self.items[index]

if __name__ == '__main__':
    h = HashTable()
    h.put('name', 'L')
    h.put('sex', 'M')
    h.put('age', '18')
    h.put('occupation', 'general')
    h.put('occupation1', 'general')
    h.put('occupation2', 'general')
    h.put('occupation3', 'general')
    h.put('occupation5', 'general')
    h.put('occupation6', 'general')
    print(h.get('name'))
    print(h.get('sex'))
    print(h.get('age'))
    print(h.get('occupation'))
    print(h.get('occupation1'))
    print(h.get('occupation2'))
    print(h.get('occupation3'))
    print(h.get('occupation5'))

ma_no_lo
关注
专栏目录
哈希表hash的扩容
TABE_的博客
05-01 3910
哈希表hash的扩容字典dict的结构哈希表hash的扩容(rehash)渐进式哈希 字典dict的结构 了解hash的扩容之前，需要先了解hash的底层实现：dict。 dict所使用的哈希表由 dict.h/dictht 结构定义： typedef struct dictht { // 哈希表数组 dictEntry **table; // 哈希表大小 unsigned long size; // 哈希表大小掩码，用于计算索引值 // 总是等于 si
【数据结构之哈希表（二）】 哈希表的扩容实现机制
weixin_43621681的博客
03-08 6343
哈希表的扩容实现机制导语哈希表什么是哈希表装载因子hashcode哈希冲突扩容方案Java中的实现Redis中的实现Objective-C中的实现结束语 导语 哈希表是实际开发中非常常用的数据结构，也很重要。了解其底层实现细节也是非常重要的。 我这篇主要是想记录一下自己的学习结果，是关于不同应用情形下实现哈希表扩容的不同方案。 哈希表 什么是哈希表 哈希表是一个散列表，里面存储的是键值对（key-...
哈希表的扩容机制
hbnn111的专栏
02-23 1500
哈希表，又称散列表，是一种常见的数据结构。通过哈希表使用某个键值可以快速定位到数据在内存中的位置。比如我们使用新华字典时，前面会有很多页的索引，我们要查找”哈“这个字，会找到拼音首字母是h的，然后查找对应的页码，这样可以快速查到对应页，不必再一页一页翻。哈希表的应用是非常广泛的，如果你之前学过操作系统，一定接触过磁盘缓冲区，bufferCache(PageCache），其内部就使用了哈希表。
深入解析 helpTransfer 方法：多线程协作中的哈希表扩容
最新发布
DC1020的博客
09-25 1084
哈希表（HashMap）是一种常用的数据结构，它通过“键值对”的形式来存储数据。它的核心思想是：根据每个“键”（key）的特征，通过一种叫做哈希函数的计算，把这个键映射到一个位置（格子）上。这样，我们就能快速找到或存储对应的值（value）。 打个比方：假设你有一个大抽屉（哈希表），你要把很多标有标签的物品放进去。你根据物品的标签（键），使用一个“算法”决定这个物品应该放在哪个小格子（具体位置）。
哈希表扩容简述
JohnJim的博客
10-24 2772
哈希表什么时候扩容？ 影响哈希表扩容的因素有两个，本身的容量CapacityCapacityCapacity和负载因子LoadFactorLoadFactorLoadFactor，当前的哈希表大小大于Size>Threshold=Capacity∗LoadFactorSize>Threshold=Capacity*LoadFactorSize>Threshold=Capacity∗LoadFactor的时候，哈希表就需要扩容。负载因子一般为0.75，这就好比我们电脑C盘比如100G，实际上
javascript数据结构与算法----哈希表扩容
Seeyoucm
06-15 569
哈希表扩容思想与实现
哈希表扩容
shou_ren_bai_bu的博客
05-19 308
我们在来将讲一个哈希表的概念: 哈希表扩容.在什么时候调用扩容方法呢?如果我们不断的删除数据呢?修改remove方法。
数据结构与算法 — 哈希函数及其实现、哈希表的实现、哈希表的扩容
m0_59897687的博客
01-10 1117
哈希表哈希表哈希表.zip
05-29
在实际应用中，为了提高性能，哈希表通常会预先设定一个较大的容量，并在负载因子（已存储元素数量/总容量）达到一定程度时进行动态扩容。 总的来说，哈希表是一种高效的数据结构，通过哈希函数和冲突解决策略实现...
数据结构与算法——哈希表及哈希扩容（Java实现）
nswdiphone6的博客
02-25 1448
哈希表 1. 哈希表的定义 哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。key（键值）和存储地址的映射 可以把哈希表理解为一个数组，每个索引对应一个存储位置，哈希表的索引并不像普通数组的索引那样，从0到length-1，而是由关键字(数据本身)通过哈希函数得到。而当使用哈希表进行查询的时候，就是再次使用哈希函数将key转换
Hash表的扩容（转载）
dgxwrj
10-09 1675
Hash表（Hash Table）        hash表实际上由size个的桶组成一个桶数组table[0...size-1] 。当一个对象经过哈希之后，得到一个相应的value , 于是我们把这个对象放到桶table[ value ]中。当一个桶中有多个对象时，我们把桶中的对象组织成为一个链表。这在冲突处理上称之为拉链法。   负载因子（load factor）        
哈希函数2：用于哈希表的存储和扩容
weixin_46838716的博客
05-27 990
1）哈希表的存储，查询，都是要经过哈希函数转换地址的，f%N 2）哈希表往往是固定长度，当容量不够，自动扩容，但是整体上哈希表的操作仍然是o(1)时间复杂度！ 3）笔试求AC，可以不考虑空间复杂度，但是面试既要考虑时间复杂度最优，也要考虑空间复杂度最优。
HashMap扩容
m0_66941325的博客
07-13 1274
HashMap在JDK1.8的时候使用数组+链表+红黑树---也叫哈希桶。静态内部类Node就是一个节点，多个Node节点构成链表，当链表长度大于8，数据总量超过64转为红黑树。关于参数的源码设置关于HashMap初始值为2^(4)=16hash桶最大容量为2^(30)转化因子为0.75当链表长度为8时，且数组最大数据量为64时会产生树化，由链表转为红黑树当链表长度小于6时，会从红黑树退回链表。
JS数据结构-哈希表-扩容操作
weixin_42738354的博客
01-11 332
一.哈希表扩容 HashTable.prototype.resize = function(newLimit){ // 1.保存旧的数组内容 var oldStorage = this.storage // 2.重置所有的属性 this.storage = [] this.count = 0 this.limit = newLimit // 3.遍历oldStorage中所有的bucket for(var i = 0; i < oldStorage.length; i++){
数据结构113-哈希表的扩容实现
qq_41632427的博客
12-16 115
前端
哈希表扩容实现 JS
weixin_44828588的博客
03-12 213
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>D.
Redis的哈希表是如何扩容的？
L的博客
04-14 2397
当元素数量比较少的时候就需要缩容以节约不必要的内存。为ht[1]分配空间，ht[0].used当前值为4，8恰好是第一个大于等于4的2的N次幂，那么当前就会将ht[1]哈希表大小设置为8。ht[2]：两个哈希表，字典使用的哈希表是ht[0]，ht[1]则是当对ht[0]哈希表进行rehash时使用。迁移过程中，新增的数据只会存在ht[1]中，而不会存放到ht[0]，ht[0]只会减少不会新增。不会，因为在迁移时，首先会从ht[0]读取数据，如果ht[0]读不到，则会去ht[1]读。
Hash表为什么要扩容？
daitu3201的博客
01-22 1226
        Hash表示重要的数据结构之一，其可以采用多种方法避免冲突，常用的一种是：链接法。采用链接法来处理Hash冲突时，当Hash表中的项太多，也就是Hash冲突比较高的时候，Hash表的遍历就蜕变成单链表，此时为了提供Hash的性能，Hash表需要扩容。扩容方案可以参见live555、memcached等项目。...
散列表（哈希表）
m0_65213200的博客
08-26 677
散列表
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值