Python篇——数据结构与算法（第六部分：哈希表）

最新推荐文章于 2024-07-12 19:06:42 发布
最新推荐文章于 2024-07-12 19:06:42 发布
阅读量4k 收藏 24
点赞数 2
分类专栏： Python基础学习——算法 文章标签： python 数据结构 算法 哈希算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42120059/article/details/131188575
版权

 

目录

1、直接寻址表

2、直接寻址表缺点

3、哈希

4、哈希表

5、解决哈希冲突

6、拉链法

7、常见哈希函数

8、哈希表的实现

8.1迭代器iter（）和__iter__

8.2str（）和repr（）

8.3代码实现哈希表

8.4哈希表的应用

 1、直接寻址表

 

2、直接寻址表缺点

3、哈希

  • 直接寻址表：key为k的元素放到k的位置上
  • 改进直接寻址表：哈希（Hashing）
    • 构建大小为m的寻址表T
    • key为k的元素放到h（k）的位置上
    • h（k）是一个函数，其将域U映射到表T[0,1,2,...,m-1]

4、哈希表

 5、解决哈希冲突

 6、拉链法

 7、常见哈希函数

 8、哈希表的实现

 8.1迭代器iter（）和__iter__

  • 从根本上说，迭代器就是有一个next()方法的对象，而不是通过索引来计数。
  • 迭代器更大的功劳是提供了一个统一的访问集合的接口。
  • 迭代器为类序列对象提供了一个类序列的接口。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。
  • 迭代器只能往前不会后退。
  • python的迭代无缝地支持序列对象，而且它还允许程序员迭代非序列类型，包括用户定义的对象。
  • 迭代器用起来很灵巧，你可以迭代不是序列但表现出序列行为的对象，例如字典的键、一个文件的行。
def iter_test():
    i = iter('happy')#!!!
    try:
        while True:
            print i.next()
    except StopIteration:
        pass

    s = {'one':1,'two':2,'three':3}
    print s
    m = iter(s) #!!!
    try:
        while True:
            print m.next()  #s[m.next()]
    except StopIteration:
        pass

if __name__ == '__main__':    
    iter_test()
h
a
p
p
y
{'three': 3, 'two': 2, 'one': 1}
three
two
one
  •  使用类实现__iter__()和next()函数
  • 另一个创建迭代器的方法是使用类，一个实现了__iter__()和next()方法的类可以作为迭代器使用。
  • next方法：返回迭代器的下一个元素
  • __iter__方法：返回迭代器对象本身
class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1 # 初始化两个计数器a，b

    def __iter__(self):
        return self # 实例本身就是迭代对象，故返回自己

    def next(self):
        self.a, self.b = self.b, self.a + self.b # 计算下一个值
        if self.a > 10: # 退出循环的条件
            raise StopIteration();
        return self.a # 返回下一个值

if __name__ == '__main__':    
    for n in Fib():
        print n 
1
1
2
3
5
8

8.2str（）和repr（）

  • Python 内置函数 repr() 和 str() 分别调用对象的__repr__和__str__
  • repr()更能显示出对象的类型、值等信息，对象描述清晰的。 而str()能够让我们最快速了解到对象的内容，可读性较高
  • 在 Python 交互式命令行下直接输出对象默认使用的是__repr__
import datetime
s = 'hello'
d = datetime.datetime.now()
print(str(s))
print(repr(s))
print(str(d))
print(repr(d))
hello
'hello'
2023-6-13 22:39:18.014587
datetime.datetime(2023, 6, 13, 22, 39, 18, 14587)

 Note：

  • map（）函数
def square(x) :            # 计算平方数
...     return x ** 2
...
>>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]

8.3、代码实现哈希表

# hash
class Linklist:
    class Node:
        def __init__(self, item=None):
            self.item = item
            self.next = None

    class LinkListIterator:
        def __init__(self, node):
            self.node = node

        def __next__(self):
            if self.node:
                cur_node = self.node
                self.node = cur_node.next
                return cur_node.item
            else:
                raise StopIteration

        def __iter__(self):
            return self

    def __init__(self, iterable=None):
        self.head = None
        self.tail = None
        if iterable:
            self.extend(iterable)

    def append(self, obj):
        s = Linklist.Node(obj)
        if not self.head:
            self.head = s
            self.tail = s
        else:
            self.tail.next = s
            self.tail = s

    def extend(self, iterable):
        for obj in iterable:
            self.append(obj)

    def find(self, obj):
        for n in self:
            if n == obj:
                return True
        else:
            return False

    def __iter__(self):
        return self.LinkListIterator(self.head)

    def __repr__(self):
        return "<<" + ",".join(map(str, self)) + ">>"


# 类似于集合的结构
class HashTable:
    def __init__(self, size=101):
        self.size = size
        self.T = [Linklist() for i in range(self.size)]

    def h(self, k):
        return k % self.size

    def insert(self, k):
        i = self.h(k)
        if self.find(k):
            print("Douplicated insert")
        else:
            self.T[i].append(k)

    def find(self, k):
        i = self.h(k)
        return self.T[i].find(k)


lk = Linklist([1, 2, 3, 4])
print(lk)

ht = HashTable()
ht.insert(0)
ht.insert(1)


# hash
class Linklist:
    class Node:
        def __init__(self, item=None):
            self.item = item
            self.next = None

    class LinkListIterator:
        def __init__(self, node):
            self.node = node

        def __next__(self):
            if self.node:
                cur_node = self.node
                self.node = cur_node.next
                return cur_node.item
            else:
                raise StopIteration

        def __iter__(self):
            return self

    def __init__(self, iterable=None):
        self.head = None
        self.tail = None
        if iterable:
            self.extend(iterable)

    def append(self, obj):
        s = Linklist.Node(obj)
        if not self.head:
            self.head = s
            self.tail = s
        else:
            self.tail.next = s
            self.tail = s

    def extend(self, iterable):
        for obj in iterable:
            self.append(obj)

    def find(self, obj):
        for n in self:
            if n == obj:
                return True
        else:
            return False

    def __iter__(self):
        return self.LinkListIterator(self.head)

    def __repr__(self):
        return "<<" + ",".join(map(str, self)) + ">>"


# 类似于集合的结构
class HashTable:
    def __init__(self, size=101):
        self.size = size
        self.T = [Linklist() for i in range(self.size)]

    def h(self, k):
        return k % self.size

    def insert(self, k):
        i = self.h(k)
        if self.find(k):
            print("Douplicated insert")
        else:
            self.T[i].append(k)

    def find(self, k):
        i = self.h(k)
        return self.T[i].find(k)


lk = Linklist([1, 2, 3, 4])
print(lk)

ht = HashTable()
ht.insert(0)
ht.insert(1)
ht.insert(3)
ht.insert(102)

print(",".join(map(str, ht.T)))

结果

<<1,2,3,4>>
<<1,2,3,4>>
<<0>>,<<1,102>>,<<>>,<<3>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>,<<>>

Process finished with exit code 0

8.4、哈希表的应用

 MD5算法

 

 

 

 

为祖国添砖JAVA
关注
  • 2
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python -哈希表
qq_51924093的博客
08-22 363
哈希表
Python 哈希表的实现与应用
酱橙的博客
09-27 5495
介绍 哈希表一个通过哈希函数来计算数据存储位置的数据结构，通常支持如下操作： insert（key，value）：插入键值对（key，value）。 get（key）： 如果存在键为key的键值对则返回其value，否则返回空值。 delete（key）： 删除键为key的键值对。 在 Python 当中最具代表的数据结构就是 字典 和 集合，底层所使用的都是哈希表这一数据结构。 直接寻址表 在学习哈希表之前，我们先了解直接寻址表的概念。 假如我们当前定义了一个集合 U，这个集合 U 里面包含了所有的
python哈希表
weixin_42490599的博客
05-16 477
上面的示例展示了如何创建、添加、查找、修改、遍历、删除和清空字典（哈希表）中的键值对。字典提供了非常高效的查找操作，平均情况下的时间复杂度为O(1)。在实际编程中，哈希表通常被广泛应用于存储键值对，并用于快速查找。在Python中，哈希表通常使用字典（dict）来实现。字典是一种无序的数据结构，其中的键（key）是唯一的，且不可变的。哈希表通过哈希函数将键映射到存储值的位置，以实现快速的查找、插入和删除操作。
基于Python3的数据结构与算法 - 17 哈希表
weixin_47702917的博客
03-21 945
哈希表是一个通过哈希函数来计算数据存储位置的数据结构，通常支持如下操作：当关键字的全域U比较小时，直接寻址是一种简单而有效的方法。U: 关键字可能出现的所有的集合。 T:根据U建立相关的T。然后关键字在相应的T中找值。直接寻址法的缺点：直接寻址表 + 哈希函数 = 哈希直接寻址表：key为k的元素放在k位置上改进直接寻址表：哈希（Hashing）哈希表（Hash Table, 又称为散列表），是一种线性表的存储结构。哈希表由一个直接寻址表和一个哈希函数组成。哈希函数 h(k) 将元素关键字k作为自变量，返回
Python实战开发及案例分析（31）—— 哈希算法
贾贾的博客
05-20 1309
哈希算法（Hash Algorithm）是一种将输入数据映射到固定大小的输出（通常是一个整数或字符串）的算法。哈希算法广泛应用于数据结构（如哈希表）、加密、数据校验等领域。下面将详细介绍哈希算法的基本原理，并通过具体案例展示如何在Python中实现和应用哈希算法。
Python数据结构：哈希表
sixqingfeng的博客
06-04 3463
哈希散列（哈希）是电脑科学中一种对资料的处理方法，通过某种特定的函数/算法（称为散列函数/算法）将要检索的项与用来检索的索引（称为散列，或者散列值）关联起来，生成一种便于搜索的数据结构（称为散列表）。哈希表是什么哈希表（散列表）是根据键（Key）直接访问内存存储位置的数据结构。根据键（Key）值将数据映射到内存中一个位置的函数称为哈希函数，根据哈希函数建立的记录数据的表称为哈希表。哈希表的特点若关键字为 ，则其值存放在的存储位置上。由此，不需比较便可直接取得所查记录。称这个对应关系 为散列函数，按这个思想
Python数据结构与算法篇（六）-- 哈希表
CarpeDiem
03-26 2167
散列表（hash table），又名‘hash表’，它用的是数组支持按照下标随机访问数据（时间复杂度O(1)）的特性，散列表其实就是基于数组结构的一种扩展。散列表这种数据结构虽然支持非常高效的数据插入、删除、查找操作，但是散列表中的数据都是通过散列函数打乱之后无规律存储的。也就说，它无法支持按照某种顺序快速地遍历数据，所以我们常常会将散列表和链表（或者跳表）结合在一起使用。
哈希表的介绍_以Python为例
心烦啊的博客
05-24 8382
数据结构篇——哈希表（以Python为例） 一、哈希表介绍 ​散列表（Hash table（英译）， 也称哈希表（音译）），是根据关键码值（Key Value）而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 ​给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash)表，函数f(key)为哈希(Hash)函数。 二、哈希表 给
《数据结构——C++实现》（第二版）课本源代码.zip
06-16
通过《数据结构——C++实现》（第二版）的学习，读者不仅能掌握各种数据结构的原理，还能熟悉C++编程，为后续的软件开发和算法设计打下坚实基础。同时，书中提供的源代码是宝贵的实践资源，可以帮助读者在实践中学习...
数据结构教案——PPT与程序代码
06-11
本资料包"数据结构教案——PPT与程序代码"提供了第四版课程的详细教学资源，包括PPT演示文稿和实际编程代码，非常适合学习者或教师使用。 首先，PPT部分通常会涵盖以下关键知识点： 1. **数组**：基础数据结构，...
《数据结构》--算法实现及解析（第二版）
11-09
《数据结构》--算法实现及解析（第二版）是一本深度探讨数据结构及其算法实现的教材，它与著名计算机科学家严蔚敏教授的原著紧密配合，旨在帮助读者深入理解和掌握数据结构这一计算机科学的核心概念。这本书是学习和...
哈希表的设计与实现.rar
05-30
哈希表是一种高效的数据结构，它通过特定的函数——哈希函数，将任意大小的键（key）映射到一个固定大小的数组中，从而实现快速的查找、插入和删除操作。这种数据结构广泛应用于软件工程、数据库系统、缓存等场景。...
Python:简单的Python代码
03-30
这个名为“简单的Python代码”的压缩包可能包含了一些基本的Python编程示例，涉及到了字符串操作、数据结构（如列表、元组和字典）以及密码学算法。 首先，让我们了解一下Python中的字符串。在Python中，字符串是不...
python中Hash使用
weixin_45730532的博客
05-13 3641
hash使用还是比较多的
Python中哈希表的实现（萌新的一天）
yuzhou1371的博客
11-09 179
今天写了波python，感觉好久没写有点生疏了，今天就学点新东西，练练手感。选了个哈希表（要不是C没有内置哈希，我说不定又拖延了）那就开始吧，首先介绍一下哈希算法，这个算法可以把输入的数字转换为固定长度的哈希值，即使是非常小的差距，最终生成的哈希值差距也会很大（虽然怎么定义哈希值相似程度还不是我这个萌新该考虑的）。所以哈希算法一般用于密码学、数据完整性校验、数据索引等领域。
python实现哈希表
面向对象的笔记
09-06 2835
# python 实现哈希表 class HashTable: """ 哈希函数的构造 解决冲突 """ def __init__(self, source): self.source = source self._index = [] self._val = [] self.table =...
学了那么久Python还什么都做不了，我觉得你该试试这个方法了
热门推荐
龙叔的博客
11-08 1万+
答应我，别再做无用功了
【持续集成_05课_Linux部署SonarQube及结合开发项目部署】
最新发布
weixin_42333261的博客
07-12 357
前置条件：sonarQube不能使用root账号进行启动，所以需要创建普通用户及。3）CMD上传qube文件-不能传到home路径下哦。2）添加用户、组名、密码。4）检查并解压上传的包。
聊聊如何在内网下构建大模型微调环境
python1234567_的博客
07-12 967
LlamaFactory新版更新后，还是比较方便，只是说llamafactory-cli命令的确是有点蒙，踩个坑就好了。对于LlamaFactory微调来说，本身不难，毕竟都是配置；主要是在内网环境下的依赖包拉取安装是真麻烦，但其实也还好。走一遍的话，还是可以学到很多的。​。
哈希表 python
08-19
哈希表（Hash Table）是一种数据结构，它可以快速地插入和查找数据。在 Python 中，哈希表被称为字典（Dictionary），它使用键值对（key-value pairs）来存储数据。 在 Python 中创建一个哈希表（字典）的示例代码如下： ```python hash_table = {} # 创建一个空的哈希表 # 向哈希表中添加键值对 hash_table["key1"] = "value1" hash_table["key2"] = "value2" hash_table["key3"] = "value3" # 访问哈希表中的值 print(hash_table["key1"]) # 输出：value1 # 遍历哈希表中的键值对 for key, value in hash_table.items(): print(key, value) ``` 哈希表的优势在于它可以在常数时间内完成插入和查找操作，即使在大量数据的情况下，效率也非常高。但是需要注意的是，哈希表的键值对是无序的，因此遍历时不能保证顺序。此外，哈希表的键必须是不可变类型（如字符串、整数、元组等），而值可以是任意类型。 希望这个简单的示例能帮助到您！如果您有任何其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值