Python数据结构与算法——数据结构(链表、哈希表、树)

已于 2024-04-03 20:34:38 修改
阅读量1.3k 收藏 16
点赞数 56
分类专栏： python数据结构与算法 文章标签： python 数据结构 算法
于 2024-03-31 22:56:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63043783/article/details/137195523
版权

目录

链表

    链表介绍

    创建和遍历链表

    链表节点插入和删除

    双链表

    链表总结——复杂度分析

哈希表(散列表)

哈希表介绍

哈希冲突

哈希表实现

哈希表应用

树

树

树的示例——模拟文件系统

二叉树

二叉树的链式存储

 二叉树的遍历

二叉搜索树

插入

查询

删除

AVL树

旋转

插入

链表

    链表介绍

        链表是由一系列节点组成的元素集合，每个节点包含两部分，数据域item和指向下一个节点的指针next。通过节点之间的相互连接，最终串联成一个链表。

节点定义：

class Node(object):
    def __init__(self, item):
        self.item = item
        self.next = None

    创建和遍历链表

        头插法/尾插法

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

# 创建链表（头插法）
def crweate_linklist_head(li):
    head = Node(li[0])
    for element in li[1:]:
        node = Node(element)
        node.next = head
        head = node
    return head

# 创建链表（尾插法）
def crweate_linklist_tail(li):
    head = Node(li[0])
    tail = head
    for element in li[1:]:
        node = Node(element)
        tail.next = node
        tail = node
    return head

# 打印链表（遍历）
def print_linklist(lk):
    while lk:
        print(lk.item, end=',')
        lk = lk.next
    print()

    链表节点插入和删除

        插入是创建一个节点，将该节点指向插入位置的下一个节点，上一个节点指向该节点。

        删除是将上一个节点的next指向下一个节点。

    双链表

        双链表每个节点有两个指针：一个指向后一个节点，另一个指向前一个节点。

节点定义：

class Node(object):
    def __init__(self, item=None):
        self.item = item
        self.next = None
        self.prior = None

    链表总结——复杂度分析

  •         按元素值查找：O(n)
  •         按下标查找：O(n)
  •         在某元素后插入：O(1)
  •         删除某元素：O(1)

链表在插入和删除的操作上明显快于顺序表

链表的内存可以更灵活分配

链表这种链式存储的数据结构对树和图的结构有很大启发性

哈希表(散列表)

哈希表介绍

介绍：哈希表是一个通过哈希函数来计算数据存储位置的数据结构，通常支持如下操作：

  • insert(key, value)：插入键值对(key, value)
  • get(key)：如果存在键为key的键值对，返回其valve，否则返回空值
  • delete(key)：删除键为key的键值对

哈希表是一种线性表的存储结构。哈希表由一个直接寻址表和一个哈希函数构成。哈希函数h(k)将元素关键字k作为自变量，返回元素的存储下标。

哈希冲突

哈希冲突：由于哈希表的大小是有限的，而要存储的值的总数量是无限的，因此对于任何哈希函数，都会出现两个不同元素映射到同一个位置上的情况。

1.开放寻址法：如果哈希函数返回的位置已经有值，则可以向后探查新的位置来存储这个值。

  • 线性探查：如果位置i被占用，则探查i+1, i+2......
  • 二次探查：如果位置i被占用，则探查i+1^2, i-1^2, i+2^2, i-2^2,......
  • 二度哈希：有n个哈希函数，当使用第一个哈希函数h1发生冲突时，则尝试使用h2，h3......

2.拉链法：哈希表每个位置都连接一个链表，当冲突发生时，冲突的元素将被加到该位置链表的最后。

常见哈希函数：

  • 除法哈希法：h(k) = k % m
  • 乘法哈希法：h(k) = floor(m*(A*key%1))
  • 全域哈希法：h_{a,b}(k) = ((a*key + b) mod p)mod m  a,b = 1, 2, ...,p-1

哈希表实现

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  # 当遍历结束时抛出StopIteration异常

        def __iter__(self):
            return self  # 返回迭代器自身

    # 初始化链表
    def __init__(self, iterable=None):
        self.head = None  # 头节点
        self.tail = None  # 尾节点
        if iterable:
            self.extend(iterable)  # 如果传入可迭代对象，则调用extend方法进行扩展

    # 在链表尾部添加节点
    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  # 返回True
        else:
            return False  # 找不到目标元素时返回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 _ 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("Duplicated Insert.")
        else:
            self.T[i].append(k)

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


ht = HashTable()

for i in range(200):
    ht.insert(i)

# print(",".join(map(str, ht.T)))
print(ht.find(203))

哈希表应用

        python的字典，集合都是哈希表

        md5算法

树

树

介绍：树是一种数据结构

  • 树是一种可以递归定义的数据结构
  • 树是由n个结点组成的集合
  • 如果n=0，那这是一棵空树
  • 如果n>0，那存在一个结点作为树的根结点，其他结点可以分为m个集合，每个集合本身又是一棵树

一些概念：

  • 根结点、叶子结点
  • 树的深度/高度
  • 树的度
  • 孩子结点、父结点
  • 子树

树的示例——模拟文件系统

# 节点
class Node:
    def __init__(self, name, type = 'dir'):
        self.name = name
        self.type = type  # 'dir' or 'file'
        self.children = []  # 存儿子节点
        self.parent = None  # 指向父节点

    def __repr__(self):
        return self.name

# 树类
class FileSystemTree:
    def __init__(self):
        self.root = Node('/')
        self.now = self.root
    
    # 创建目录
    def mkdir(self, name):
        # name得是一个目录，以'/'结尾
        if name[-1] != '/':
            name += '/'
        node = Node(name)
        self.now.children.append(node)
        node.parent = self.now

    # 展示所有目录
    def ls(self):
        return self.now.children

    # 切换目录
    def cd(self, name):
        # 只支持往下走一层
        if name[-1] != '/':
            name += '/'
        if name == '../':
            self.now = self.now.parent
            return
        for child in self.now.children:
            if child.name == name:
                self.now = child
                return
        raise ValueError("invalid dir")

tree = FileSystemTree()
tree.mkdir("var/")
tree.mkdir("bin/")
tree.mkdir("usr/")

print(tree.ls())

tree.cd("bin")
tree.mkdir("python")

print(tree.ls())

tree.cd("../")
print(tree.ls())

二叉树

二叉树就是度不超过2的树

  • 每个结点最多有两个孩子结点
  • 两个孩子结点被区分为左孩子结点和右孩子结点

完全二叉树

  • 满二叉树：一个二叉树，如果一个层的节点数都达到最大值，则这个二叉树就是满二叉树
  • 完全二叉树：叶子节点只能出现在最下层和次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树

二叉树的存储方式（表示方式）

  • 链式存储方式
  • 顺序存储方式（堆排序用这个）——用列表来存
  • 父结点和左孩子结点的编号下标的关系

                0-1 1-3 2-5 3-7 4-9

                i -> 2i+1

  • 父结点和右孩子结点的编号下标的关系

                0-2 1-4 2-6 3-8 4-10

                i -> 2i+2

之前学过线性存储，这里是链式存储

二叉树的链式存储

将二叉树的节点定义为一个对象，节点之间通过类似链表的链接方式来连接。

节点定义：

class BiTreeNode:
    def __init__(self, data):
        self.data = data
        self.lchild = None
        self.rchild = None

 二叉树的遍历

二叉树的遍历方式：

  • 前序遍历：如果不空，先访问根，再访问左子树，最后访问右子树。
  • 中序遍历：如果不空，先访问左子树，再访问根，最后访问右子树。
  • 后序遍历：如果不空，先访问左子树，再访问右子树，最后访问根。
  • 层次遍历：一层一层访问。
# 前序遍历
def pre_order(root):
    if root:
        print(root.data, end=',')
        pre_order(root.lchild)
        pre_order(root.rchild)

# 中序遍历
def in_order(root):
    if root:
        in_order(root.lchild)
        print(root.data, end=',')
        in_order(root.rchild)

# 后序遍历
def post_order(root):
    if root:
        post_order(root.lchild)
        post_order(root.rchild)
        print(root.data, end=",")

# 层次遍历

from compileall import queue
def level_order():
    queue = deque()
    queue.append(root)
    while len(queue) > 0:  # 只要队不空
        node = queue.popleft()
        print(node.data, end=',')
        if node.lchild:
            queue.append(node.lchild)
        if node.rchild:
            queue.append(node.rchild)

二叉搜索树

是一颗二叉树，并且满足左子树的根比根小，右子树的根比根大。

二叉搜索树的操作：查询、插入、删除

二叉搜索树的效率：

  • 平均情况下，二叉搜索树进行搜索的时间复杂度为O(logn)
  • 最坏情况下，二叉搜索树可能非常偏斜

解决方案：

  • 随机化插入
  • AVL树

插入

两种方式：递归和非递归

class BiTreeNode:
    def __init__(self, data):
        self.data = data
        self.lchild = None  # 左孩子
        self.rchild = None  # 右孩子
        self.parent = None

class BST:
    def __init__(self, li=None):
        self.root = None
        if li:
            for val in li:
                self.insert_no_rec(val)  # 根据列表构造树

    # 插入(递归)
    def insert(self, node, val):
        if not node:
            node = BiTreeNode(val)
        elif val < node.data:
            node.lchild = self.insert(node.lchild, val)
            node.lchild.parent = node
        elif val > node.data:
            node.rchild = self.insert(node.lchild, val)
            node.rchild.parent = node
        return node

    # 插入(非递归)
    def insert_no_rec(self, val):
        p = self.root
        if not p:  # 空树时
            self.root = BiTreeNode(val)
            return
        while True:
            if val < p.data:
                if p.lchild:
                    p = p.lchild
                else:   # 左孩子不存在
                    p.lchild = BiTreeNode(val)
                    p.lchild.parent = p
                    return
            elif val > p.data:
                if p.rchild:
                    p = p.rchild
                else:
                    p.rchild = BiTreeNode(val)
                    p.rchild.parent = p
                    return
            else:
                return

查询

两种方式：递归和非递归

    # 查询(递归)
    def query(self, node, val):
        if not node:
            return None
        if node.data < val:
            return self.query(node.rchild, val)
        elif node.data > val:
            return self.query(node.lchild, val)
        else:
            return node

    # 查询(非递归)
    def query_no_rec(self, val):
        p = self.root
        while p:
            if p.data < val:
                p = p.rchild
            elif p.data > val:
                p = p.lchild
            else:
                return p
        return None

删除

三种情况：

  • 叶子节点——直接删除
  • 要删除的节点只有一个孩子——将此节点的父亲与孩子连接，然后删除该节点
  • 要删除的节点有两个孩子——将其右子树的最小节点删除，并替换当前节点
    # 情况1:node是叶子节点
    def __remove_node_1(self, node):
        if not node.parent:  # 如果是根节点
            self.root = None
        elif node == node.parent.lchild:  # node是它父亲的左孩子
            node.parent.lchild = None
        else:  # 是右孩子
            node.parent.rchild = None

    # 情况2.1:node只有一个左孩子
    def __remove_node_21(self, node):
        if not node.parent:  # 如果是根节点
            self.root = node.lchild
            node.lchild.parent = None
        elif node == node.parent.lchild:  # 是它父亲的左孩子
            node.parent.lchild = node.lchild
            node.lchild.parent = node.parent
        else:  # 是它父亲的右孩子
            node.parent.rchild = node.lchild
            node.lchild.parent = node.parent

    # 情况2.2:node只有一个右孩子
    def __remove_node_22(self, node):
        if not node.parent:
            self.root = node.rchild
            node.rchild.parent = None
        elif node == node.parent.lchild:  # 是它父亲的左孩子
            node.parent.lchild = node.rchild
            node.rchild.parent = node.parent
        else:  # 是它父亲的右孩子
            node.parent.rchild = node.rchild
            node.rchild.parent = node.parent

    # 情况3:左右节点都有
    def delete(self, val):
        if self.root:  # 不是空树再删
            node = self.query_no_rec(val)
            if not node:  # 如果node不存在
                return False
            if not node.lchild and not node.rchild:  # 1删除叶子节点的情况
                self.__remove_node_1(node)
            elif not node.rchild:  # 2.1只有一个左孩子
                self.__remove_node_21(node)
            elif not node.lchild:  # 2.2只有一个右孩子
                self.__remove_node_22(node)
            else:  # 3两个孩子都有
                min_node = node.rchild
                while min_node.lchild:
                    min_node = min_node.lchild
                node.data = min_node.data
                # 然后删除min_node
                if min_node.rchild:
                    self.__remove_node_22(min_node)
                else:
                    self.__remove_node_21(min_node)

AVL树

AVL树：AVL树是一棵自平衡的二叉搜索树

AVL树具有以下性质：

  • 根的左右子树的高度之差的绝对值不能超过1
  • 根的左右子树都是平衡二叉树

旋转

旋转是修正出现不平衡的树的操作

这里的旋转是服务于插入的

插入一个节点后，只有从插入节点到根节点的路径上的节点的平衡可能被改变。我们需要找出第一个破坏了平衡条件的节点，称之为K——K的两棵子树的高度差2.

插入不平衡的出现可能有四种情况：

  • 不平衡是由于对K的右孩子的右子树插入导致的：左旋
  • 不平衡是由于对K的左孩子的左子树插入导致的：右旋
  • 不平衡是由于对K的右孩子的左子树插入导致的：右旋-左旋
  • 不平衡是由于对K的左孩子的右子树插入导致的：左旋-右旋
from bst import BiTreeNode, BST

class AVLNode(BiTreeNode):  # 继承
    def __init__(self):
        BiTreeNode.__init__(self, data)
        self.bf = 0

class AVLTree(BST):
    def __init__(self, li=None):
        BST.__init__(self, li)

    # 左旋
    def rotate_left(self, p, c):
        s2 = c.lchild
        p.rchild = s2
        if s2:
            s2.parent = p

        c.lchild = p
        p.parent = c

        p.bf = 0
        c.bf = 0

    # 右旋
    def rotate_right(self, p, c):
        s2 = c.rchild
        p.lchild = s2
        if s2:
            s2.parent = p

        c.rchild = p
        p.parent = c

        p.bf = 0
        c.bf = 0

    # 右旋左旋
    def rotate_right_left(self, p, c):
        g = c.lchild

        s3 = g.rchild
        c.lchild = s3
        if s3:
            s3.parent = c
        g.rchild = c
        c.parent = g

        s2 = g.lchild
        p.rchild = s2
        if s2:
            s2.parent = p
        g.lchild = p
        p.parent = g

        # 更新bf
        if g.bf > 0:
            p.bf = -1
            c.bf = 0
        elif g.bf < 0:
            p.bf = 0
            c.bf = 1
        else:
            p.bf = 0
            c.bf = 0

    # 左旋右旋
    def rotate_left_right(self, p, c):
        g = c.rchild

        s2 = g.lchild
        c.rchild = s2
        if s2:
            s2.parent = c
        g.lchild = c
        c.parent = g

        s3 = g.rchild
        p.lchild = s3
        if s3:
            s3.parent = p
        g.rchild = p
        p.parent = g

        # 更新bf
        if g.bf < 0:
            p.bf = 1
            c.bf = 0
        elif g.bf > 0:
            p.bf = 0
            c.bf = -1
        else:
            p.bf = 0
            c.bf = 0

插入

插入一个节点可能会破坏AVL树的平衡，可以通过旋转操作来进行修正。

    def insert_no_rec(self, val):  # 重新定义，覆盖原先的方法
        # 第一步：和BST一样，先插入
        p = self.root
        if not p:  # 空树时
            self.root = BiTreeNode(val)
            return
        while True:
            if val < p.data:
                if p.lchild:
                    p = p.lchild
                else:  # 左孩子不存在
                    p.lchild = BiTreeNode(val)
                    p.lchild.parent = p
                    node = p.lchild  # node存储的就是插入的节点
                    break
            elif val > p.data:
                if p.rchild:
                    p = p.rchild
                else:
                    p.rchild = BiTreeNode(val)
                    p.rchild.parent = p
                    node = p.rchild
                    break
            else:  # val == p.data同样的元素只保留一个
                return

        # 第二步：更新balance factor
        while node.parent:  # 保证node.parent不空
            if node.parent.lchild == node:  # 传递是从左子树来的，左子树更沉了
                # 更新node.parent 的 bf -= 1
                if node.parent.bf < 0:  # 原来node.parent.bf == -1，更新后变为-2
                    # 做旋转
                    # 看node哪边沉
                    g = node.parent.parent  # 为了连接旋转之后的子树
                    x = node.parent  # 旋转前的子树的根
                    if node.bf > 0:
                        n = self.rotate_left_right(node.parent, node)
                    else:
                        n = self.rotate_right(node.parent, node)
                    # 最后将n 和 g 连接起来
                elif node.parent.bf > 0:  # 原来node.parent.bf == 1, 更新后变成0
                    node.parent.bf = 0
                    break
                else:  # 原来node.parent.bf == 0, 更新后变成-1
                    node.parent.bf = -1
                    node = node.parent
                    continue
            else:  # 传递是从右子树来的，右子树更沉了
                # 更新node.parent 的 bf += 1
                if node.parent.bf > 0:  # 原来node.parent.bf == 1，更新后变为2
                    # 做旋转
                    # 看node哪边沉
                    g = node.parent.parent  # 为了连接旋转之后的子树
                    x = node.parent  # 旋转前的子树的根
                    if node.bf < 0:
                        n = self.rotate_right_left(node.parent, node)
                    else:
                        n = self.rotate_left(node.parent, node)
                    # 记得连起来
                elif node.parent.bf < 0:  # 原来node.parent.bf == -1, 更新后变成0
                    node.parent.bf = 0
                    break
                else:  # 原来node.parent.bf == 0, 更新后变成1
                    node.parent.bf = 1
                    node = node.parent
                    continue

            # 连接旋转后的子树
            n.parent = g
            if g:  # 看g是否存在
                if x == g.lchild:
                    g.lchild = n
                else:
                    g.rchild = n
                break
            else:
                self.root = n
                break

代码自己手动敲一遍理解更深哦！

依彡
关注
  • 56
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【数据结构与算法】刷题汇总 Python 版
dongrixinyu的专栏
12-11 2万+
我的BLOG里写了一部分算法和数据结构，题目都是从网上和书上找的。当然一下这些并不全面，我打算利用今后的时间把各类的算法题都用Python写一遍（因为我主要是用Python），尽可能囊括所有的算法题。写这些题并不是目的，主要还是为了能够提升自己的数据结构和算法的水平，以及码代码的速度和熟练度。所有的代码都提交到了我的 github 上面：冬日新雨的github：数据结构和算法刷题代码下载1、字符串：
python数据结构及算法
weixin_45841852的博客
02-13 2352
python数据结构及算法 一. 数据结构与算法 1. 算法的概念：算法是独立存在的一种解决问题的方法和思想 2. 算法的特征：输入，输出，有穷性，确定性，可行性 3. 时间复杂度是实现算法程序所需要的时间，即算法的优劣 4. 数据结构是指数据对象中数据元素之间的关系 5. 程序 = 数据结构 + 算法 6. 算法是为了解决实际问题而设计的，数据结构是算法需要处理的问题载体 二. 顺序表 1. 顺...
Python数据结构和算法
路一直都在在在的博客
04-26 784
Python数据结构和算法 1.序列分解为单独的变量 只要对象是可迭代的(字符串，文件，迭代器，生成器)，那么就可以执行分解操作。 p = (4,5) x,y = p print(x)#4 print(y)#5 data = ['hongsong', 40, 50.1, (2012, 12, 31)] name, shares, price, date = data print(name,...
python数据结构与算法 （翻译）第一章
zongzi13545329的博客
12-01 2585
第一章 抽象数据类型算法的学习是计算机科学的基础。算法是为了在有限的时间内解决问题，而做出的一系列清晰和精确的逐步说明。算法通过将逐步指令转换成可由计算机执行的计算机程序来实现。这个翻译过程被称为计算机编程或简单编程。计算机程序由适合于该问题的编程语言来构建。编程是计算机科学重要的组成部分。计算机科学不是学习编程，也不是学习一种特定的编程语言，相反，编程和程序语言都是计算机科学用来解决问题的工具。1
Hash 哈希表
m0_52343363的博客
04-23 1240
我们学习了数据结构,其实都在做一件事情那就是 数据的结构 无论是学了啥？目的都是为了1.1 哈希表的定义（Hash table，也叫哈希表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。remark: 通过某种映射关系 比方将你映射为 阿兰图灵 那么在这个名人散列表查找到图灵时就等于找到了你。
Python 中不同数据结构或算法的实现，包括 ADT、哈希表、链表、排序、树和图
06-07
链表操作： 插入 附加 回报指数 更新索引 删除索引 插入前索引 插入后索引 删除数据 删除所有数据 insertAfterEveryData insertBeforeEveryData 删除列表 复制列表 findMthToLastNode 类型： 带头指针的单 LL 双 LL ...
用python学习数据结构与算法 教程
02-02
在本教程中，我们将深入探讨如何使用Python语言学习数据结构与算法，这是一门对于任何计算机科学或软件工程领域的专业人士至关重要的学科。Python因其简洁易读的语法而成为初学者和专家的首选语言，它提供了丰富的库...
Python 超详细算法与数据结构视频教程
最新发布
05-06
课程的目录结构如下，每一章都有配套的文字讲义(markdown)，示例代码，视频讲解，详细的讲解一般会放在视频...python 内置常用数据结构和算法的使用。list, dict, set, collections 模块，heapq 模块 面试笔试常考算法
Python3 数据结构与算法的介绍及应用。1. 数据结构：数组、链表、栈等等
12-27
Python3 数据结构与算法的介绍及应用。1. 数据结构：数组、链表、栈、队列、树、堆、图； 2. 典型排序算法：冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序、快速排序、桶排序、计数排序、基数排序； 3....
python数据结构实现（一）：数组和链表及相关LeetCode题 数组和链表.pdf
04-18
在Python中，数组和链表是两种基本的数据结构，它们在处理数据时有着不同的特性和应用场景。本篇文章将深入探讨这两种数据结构的实现，并结合LeetCode题目进行实战演练。 首先，我们来看数组。数组是一种线性表的...
链式哈希表
qq_41721746的博客
05-24 3717
线性哈希表的缺陷 但是链式哈希表可以采用分段的锁，这样既保证了线程安全，又有一定的并发量，提高了效率。当前我们库里面无序的关联容器并没有实现多线程中的线程安全问题，就是并没有去加锁，但是这并不妨碍当我们真正想要实现一个线程安全，能够直接用在多线程环境下的基于哈希表实现的无序关联容器，我们在代码上可以通过分段锁来实现。
【数据结构】哈希表（Map和Set）
haoshaokang_的博客
06-07 1271
3️⃣当堆中不够K个元素时，就直接入堆，入够K个元素之后，此时按照比较规则，堆顶元素一定是出现频率最小的，如果堆中还有其他元素和堆顶元素频率相同，那堆顶元素应该是字典序靠后的。4️⃣再接着遍历集合元素，如果当前元素比堆顶元素频率高，则出堆顶元素，入当前元素；如果当前元素和堆顶元素频率一样高，再比较字典序，如果堆顶元素靠后，则出堆顶元素，入当前元素。5️⃣最终依次出堆顶元素到List中，然后逆序List即可。
chatgpt赋能python：Python如何遍历单链表
b45e1933f46的博客
06-18 148
首先，我们需要定义Node类和LinkedList类。Node类包括两个属性：data和next，数据可以是任何类型，next是指向下一个节点的指针。LinkedList类包括一个头结点和一些方法，如添加节点、删除节点和遍历链表等。其中头结点是不包含数据的，只是一个指向第一个节点的指针。在Python中，我们可以通过定义Node类和LinkedList类来实现单链表的操作。在遍历单链表时，我们可以使用while循环语句来获取每个节点的数据。希望这篇文章能够帮助读者了解如何在Python中遍历单链表。
【Python——链表】
m0_70964767的博客
08-05 1万+
链表（Linked list）是一种常见的基础数据结构，是一种线性表，在每一个节点（数据存储单元）里存放下一个节点的位置信息。
哈希表【Hash Table】原理、特点及实现方式！一文彻底搞定哈希表！
KIDfengKID的博客
07-01 1699
详细易懂hash table
哈希表(哈希映射)
weixin_49329785的博客
09-22 436
基本介绍 散列表(Hash table,也叫哈希表)，是根据关键码值(Key value)而直接进行访问的数据结构，也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 哈希表的作用相当于一个缓存层 哈希表的内存布局图 哈希表例题代码实现 有一个公司，当有新的员工来报道时，要求将该员工的信息加入(id,性别，年龄，名字，住址...),当输入该员工的id时，要求查找到该员工所有信息。 要求： 不使用数据库，速度越.
【Python】python链表
热门推荐
weixin_45718987的博客
05-31 2万+
python链表总结 原Blog链接：https://blog.csdn.net/qq_44941689/article/details/122402938 1. 链表基本类型 链表（Linked List）：一种线性表数据结构。它使用一组任意的存储单元（可以是连续的，也可以是不连续的），来存储一组具有相同类型的数据。即「链表」 是实现线性表的链式存储结构的基础。 单链表每个数据元素占用若干存储单元的组合称为一个「链节点」，还要存放一个指出这个数据元素在逻辑关系上的直接后继元素所在链节点的地址，该地址被
哈希表（数组+链表）
qq_51728440的博客
03-15 230
模拟哈希表 1.雇员Emp(节点)类 2.EmpLinkedList(链表)类 3.HashTab哈希表类。内容包括对哈希表的添加、查找(根据输入的员工id)、删除(根据输入的员工id)以及显示。哈希表可以将常访问的数据存储在缓存层，以缓解数据库的访问。
python数据结构与算法分析(第2版)pdf
11-08
本书的主要内容包括Python中的基本数据结构，如列表、数组、链表、栈、队列、哈希表等，以及常见的算法，如搜索算法、排序算法、图算法等。 这本书的优点在于结合了Python的编程语言特点，给出了相应的示例代码，并...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值