数据结构 | 堆

本文简要总结堆的概念。

更新:2023 / 8 / 20


数据结构 | 堆

    • 概念
    • 方法
      • 插入
        • 步骤
      • 删除
        • 步骤
    • 示例
      • 大根堆
        • 插入
        • 删除
        • 堆排序
  • 代码实现
    • Python
      • 大根堆
        • 1.
        • 2. heapq
      • 小根堆
        • 1.
        • 2. heapq
  • 参考链接


概念

如果谈到堆排序,那么必然要说说什么是 大根堆 max heap小根堆 min heap 1

  • max heap
    若根节点存在左右子节点,那么根节点的值大于或等于左右子节点的值;
    是根结点大于或者等于左右子节点的二叉树;
  • min heap
    若根节点存在左右子节点,那么根节点的值小于或等于左右子节点的值;
    是根结点x小于或者等于左右子节点的二叉树;

那么,我们可以总结出关于 max heapmin heap 的结论:

  1. 堆是一颗完全二叉树;
  2. min heap 的根节点是堆中最小值;
    max heap 的根节点是堆中最大值;
  3. 堆适合采用顺序存储;

方法

堆最重要的两个方法就是 插入删除 方法。


插入

将一个元素插入到堆中,使之依然成为一个堆。


步骤

  1. 将元素插入到堆的尾部;
  2. 查看每个子树是否符合大(小)根堆的特点。若不符合则将节点逐层向上调整根和叶子节点的位置,直至从该节点的父节点出发到根节点是一个有序序列,直到所有节点都满足条件,最终依然构成一个堆。

删除

堆在删除元素时,只可以删除根节点,然后使剩下的节点依然成为一个堆。


步骤

  1. 删除根节点,用堆中最后元素进行填充;
  2. 查看每个子树是否符合大(小)根堆的特点。若不符合则进行调整,直至所有节点都满足条件。

示例

堆的构建过程其实就是构建一个符合大根堆或者小根堆的完全二叉树,那么就可以使用顺序表来进行存储。


大根堆

下面举例说明堆的构建过程:
将无序序列 [49, 38, 65, 97, 76, 13, 27, 40] 构建大根堆。


  1. 插入 49
    在这里插入图片描述

  2. 插入 38
    在这里插入图片描述

  3. 插入 65
    在这里插入图片描述
    因为要建立 max heap4965 不符合大根堆的特点,对其进行调整。调整后,如下所示:在这里插入图片描述

  4. 插入 97
    在这里插入图片描述
    9738 发生冲突,进行调整,
    在这里插入图片描述
    在这里插入图片描述

  5. 插入 76
    在这里插入图片描述
    7665 发生冲突,进行调整,
    在这里插入图片描述

  6. 插入 13在这里插入图片描述

  7. 插入 27
    在这里插入图片描述

  8. 插入 40
    在这里插入图片描述
    4038 发生冲突,进行调整,
    在这里插入图片描述
    至此,max heap 建立完成。可以看出,根节点是最大值。


插入

在上面的基础上,向 max heap 插入节点 99

  1. 插入 99
    在这里插入图片描述
    9940 发生冲突,进行调整,

在这里插入图片描述
9976 发生冲突,再次进行调整,

在这里插入图片描述
99 仍然和 97 存在冲突,再次进行调整,
在这里插入图片描述
至此,所有节点都符合堆的特性,99 被成功插入 max heap


删除

在上面的基础上,因为只能删除根节点,所以删除 max heap99

  1. 找到堆中最后的节点 40
    在这里插入图片描述
    删除根节点 99,根节点被删除后由最后的节点 40 进行补位。
    在这里插入图片描述
    此时的根节点 40 并不大于或等于左右子节点。因此,寻找此时左右子节点中的最大值 97 与此时的根节点 40 互换以进行调整,
    在这里插入图片描述
    此时的节点 40 并不大于或等于左子节点 76。因此,寻找此时节点 4076 进行互换,
    在这里插入图片描述
    至此,所有节点都符合堆的特性,99 被成功从 max heap 删除。

堆排序

堆排序是如何实现的呢?
堆排序其实就是堆的删除过程。每次删除的都是堆的根节点,删除后再进行调整,使得剩下的节点还是堆,然后再删除根节点。重复进行。直至堆中只有一个元素时,便可直接输出。那么删除过程中产生的这个序列即是一个有序序列 2

在这里插入图片描述
同样以上面的例子为例,来看看堆排序是如何实现的:

  1. 删除 99
    删除 99 的过程可参考上面的 删除 部分的内容。在删除 99 后,剩下的元素构成的堆如下所示:
    在这里插入图片描述
  2. 删除 97
    剩下的元素构成的堆如下所示:
    在这里插入图片描述
  3. 删除 76
    剩下的元素构成的堆如下所示:
    在这里插入图片描述
  4. 删除 65
    剩下的元素构成的堆如下所示:
    在这里插入图片描述
  5. 删除 49
    剩下的元素构成的堆如下所示:
    在这里插入图片描述
  6. 删除 40
    剩下的元素构成的堆如下所示:
    在这里插入图片描述
  7. 删除 38
    剩下的元素构成的堆如下所示:
    在这里插入图片描述
  8. 删除 27
    剩下的元素构成的堆如下所示:
    在这里插入图片描述
    至此,堆中仅剩一个元素 13
    所以,最后排序后的序列为 [99, 97, 76, 65, 49, 40, 38, 27, 13],排序完成。

代码实现

Python

大根堆

1.

以无序序列 [49, 38, 65, 97, 76, 13, 27, 40,99] 为例,

def maxheap(arr, end):print('+' * 20 + ' max heapify ')height = int((end+1)/ 2 - 1)print(f"{'height':20}: {height}")for root in range(height, -1, -1):while True:child = root * 2 + 1print(f"{'root':20}: {root}\n{'child':20}: {child}\n{'end':20}: {end}")if child > end:print(f"-" * 20 + f' child {child} > end {end}, exit loop')breakif child+1 <= end and arr[child] < arr[child+1]:print(f"-" * 20 + f' child+1 {child + 1} <= end {end} and arr[child] {arr[child]} < arr[child+1] {arr[child + 1]}')child = child + 1print(f"{'child now':20}: {child}")if arr[root] < arr[child]:print(f"-" * 20 + f' arr[root] {arr[root]} < arr[child] {arr[child]}, root {root} child {child}')arr[root], arr[child] = arr[child], arr[root]root = childprint(f"-" * 20 + f' arr[root] {arr[root]} > arr[child] {arr[child]}, root {root} child {child} now')else:print(f"-" * 20 + f' arr[root] {arr[root]} > arr[child] {arr[child]}, root {root} child {child}, exit loop')breakreturn arrdef sortheap(arr, end):for i in range(end, 0, -1):arr[0], arr[i] = arr[i], arr[0]maxheap(arr, i-1)return arrif __name__ == '__main__':a = [49, 38, 65, 97, 76, 13, 27, 40, 99]print(f"排序前:\n{a}")print('-' * 100 + ' max heapify ')a = maxheap(a, len(a)-1)print(f"大根堆:\n{a}")print('-' * 100 + ' sort heap ')a = sortheap(a, len(a)-1)print(f"堆排序:\n{a}")

输出信息如下所示:

排序前:
[23, 15, 30, 38, 65, 97, 40, 99]
---------------------------------------------------------------------------------------------------- max heapify 
++++++++++++++++++++ max heapify 
height              : 3
root                : 3
child               : 7
end                 : 7
-------------------- arr[root] 38 < arr[child] 99, root 3 child 7
-------------------- arr[root] 38 > arr[child] 38, root 7 child 7 now
root                : 7
child               : 15
end                 : 7
-------------------- child 15 > end 7, exit loop
root                : 2
child               : 5
end                 : 7
-------------------- arr[root] 30 < arr[child] 97, root 2 child 5
-------------------- arr[root] 30 > arr[child] 30, root 5 child 5 now
root                : 5
child               : 11
end                 : 7
-------------------- child 11 > end 7, exit loop
root                : 1
child               : 3
end                 : 7
-------------------- arr[root] 15 < arr[child] 99, root 1 child 3
-------------------- arr[root] 15 > arr[child] 15, root 3 child 3 now
root                : 3
child               : 7
end                 : 7
-------------------- arr[root] 15 < arr[child] 38, root 3 child 7
-------------------- arr[root] 15 > arr[child] 15, root 7 child 7 now
root                : 7
child               : 15
end                 : 7
-------------------- child 15 > end 7, exit loop
root                : 0
child               : 1
end                 : 7
-------------------- arr[root] 23 < arr[child] 99, root 0 child 1
-------------------- arr[root] 23 > arr[child] 23, root 1 child 1 now
root                : 1
child               : 3
end                 : 7
-------------------- child+1 4 <= end 7 and arr[child] 38 < arr[child+1] 65
child now           : 4
-------------------- arr[root] 23 < arr[child] 65, root 1 child 4
-------------------- arr[root] 23 > arr[child] 23, root 4 child 4 now
root                : 4
child               : 9
end                 : 7
-------------------- child 9 > end 7, exit loop
大根堆:
[99, 65, 97, 38, 23, 30, 40, 15]
---------------------------------------------------------------------------------------------------- sort heap 
++++++++++++++++++++ max heapify 
height              : 2
root                : 2
child               : 5
end                 : 6
-------------------- child+1 6 <= end 6 and arr[child] 30 < arr[child+1] 40
child now           : 6
-------------------- arr[root] 97 > arr[child] 40, root 2 child 6, exit loop
root                : 1
child               : 3
end                 : 6
-------------------- arr[root] 65 > arr[child] 38, root 1 child 3, exit loop
root                : 0
child               : 1
end                 : 6
-------------------- child+1 2 <= end 6 and arr[child] 65 < arr[child+1] 97
child now           : 2
-------------------- arr[root] 15 < arr[child] 97, root 0 child 2
-------------------- arr[root] 15 > arr[child] 15, root 2 child 2 now
root                : 2
child               : 5
end                 : 6
-------------------- child+1 6 <= end 6 and arr[child] 30 < arr[child+1] 40
child now           : 6
-------------------- arr[root] 15 < arr[child] 40, root 2 child 6
-------------------- arr[root] 15 > arr[child] 15, root 6 child 6 now
root                : 6
child               : 13
end                 : 6
-------------------- child 13 > end 6, exit loop
++++++++++++++++++++ max heapify 
height              : 2
root                : 2
child               : 5
end                 : 5
-------------------- arr[root] 40 > arr[child] 30, root 2 child 5, exit loop
root                : 1
child               : 3
end                 : 5
-------------------- arr[root] 65 > arr[child] 38, root 1 child 3, exit loop
root                : 0
child               : 1
end                 : 5
-------------------- arr[root] 15 < arr[child] 65, root 0 child 1
-------------------- arr[root] 15 > arr[child] 15, root 1 child 1 now
root                : 1
child               : 3
end                 : 5
-------------------- arr[root] 15 < arr[child] 38, root 1 child 3
-------------------- arr[root] 15 > arr[child] 15, root 3 child 3 now
root                : 3
child               : 7
end                 : 5
-------------------- child 7 > end 5, exit loop
++++++++++++++++++++ max heapify 
height              : 1
root                : 1
child               : 3
end                 : 4
-------------------- child+1 4 <= end 4 and arr[child] 15 < arr[child+1] 23
child now           : 4
-------------------- arr[root] 38 > arr[child] 23, root 1 child 4, exit loop
root                : 0
child               : 1
end                 : 4
-------------------- child+1 2 <= end 4 and arr[child] 38 < arr[child+1] 40
child now           : 2
-------------------- arr[root] 30 < arr[child] 40, root 0 child 2
-------------------- arr[root] 30 > arr[child] 30, root 2 child 2 now
root                : 2
child               : 5
end                 : 4
-------------------- child 5 > end 4, exit loop
++++++++++++++++++++ max heapify 
height              : 1
root                : 1
child               : 3
end                 : 3
-------------------- arr[root] 38 > arr[child] 15, root 1 child 3, exit loop
root                : 0
child               : 1
end                 : 3
-------------------- arr[root] 23 < arr[child] 38, root 0 child 1
-------------------- arr[root] 23 > arr[child] 23, root 1 child 1 now
root                : 1
child               : 3
end                 : 3
-------------------- arr[root] 23 > arr[child] 15, root 1 child 3, exit loop
++++++++++++++++++++ max heapify 
height              : 0
root                : 0
child               : 1
end                 : 2
-------------------- child+1 2 <= end 2 and arr[child] 23 < arr[child+1] 30
child now           : 2
-------------------- arr[root] 15 < arr[child] 30, root 0 child 2
-------------------- arr[root] 15 > arr[child] 15, root 2 child 2 now
root                : 2
child               : 5
end                 : 2
-------------------- child 5 > end 2, exit loop
++++++++++++++++++++ max heapify 
height              : 0
root                : 0
child               : 1
end                 : 1
-------------------- arr[root] 15 < arr[child] 23, root 0 child 1
-------------------- arr[root] 15 > arr[child] 15, root 1 child 1 now
root                : 1
child               : 3
end                 : 1
-------------------- child 3 > end 1, exit loop
++++++++++++++++++++ max heapify 
height              : 0
root                : 0
child               : 1
end                 : 0
-------------------- child 1 > end 0, exit loop
堆排序:
[15, 23, 30, 38, 40, 65, 97, 99]

2. heapq

参考这里 3

import heapqa = [49, 38, 65, 97, 76, 13, 27, 40, 99]
print(f"{'排序前':20}: {a}")print('-' * 50 + ' min heapify ')
heapq.heapify(a)
print(f"{'小根堆':20}: {a}")print('-' * 50 + ' max heapify ')
newa = [(-i, a[i]) for i in range(len(a))]
heapq.heapify(newa)
print(f"{'新小根堆':20}: {newa}")
maxheap = list()
while newa:_, s = heapq.heappop(newa)print(f"_, s: {_}, {s}")maxheap.append(s)
print(f"{'大根堆':20}: {maxheap}")

输出信息如下所示:

排序前                 : [49, 38, 65, 97, 76, 13, 27, 40, 99]
-------------------------------------------------- min heapify 
小根堆                 : [13, 38, 27, 40, 76, 65, 49, 97, 99]
-------------------------------------------------- max heapify 
新小根堆                : [(-8, 99), (-7, 97), (-6, 49), (-3, 40), (-4, 76), (-5, 65), (-2, 27), (-1, 38), (0, 13)]
_, s: -8, 99
_, s: -7, 97
_, s: -6, 49
_, s: -5, 65
_, s: -4, 76
_, s: -3, 40
_, s: -2, 27
_, s: -1, 38
_, s: 0, 13
大根堆                 : [99, 97, 49, 65, 76, 40, 27, 38, 13]

小根堆

1.

以无序序列 [49, 38, 65, 97, 76, 13, 27, 40,99] 为例,

def minheap(arr, start, end):height = int((end+1)/ 2 - 1)for root in range(height, -1, -1):while True:child = root * 2 + 1if child > end:breakif child-1 >= start and arr[child] > arr[child-1]:child = child-1if arr[root] > arr[child]:arr[root], arr[child] = arr[child], arr[root]root = childelse:breakreturn arrdef sortheap(arr, start, end):for i in range(end, 0, -1):arr[0], arr[i] = arr[i], arr[0]minheap(arr, 0, i-1)return arrif __name__ == '__main__':a = [49, 38, 65, 97, 76, 13, 27, 40, 99]print(f"排序前:\n{a}")print('-' * 50 + ' min heapify ')a = minheap(a, 0, len(a)-1)print(f"小根堆:\n{a}")print('-' * 50 + ' sort heap ')arr = sortheap(a, 0, len(a)-1)print(f"堆排序:\n{a}")

输出信息如下所示:

排序前:
[49, 38, 65, 97, 76, 13, 27, 40, 99]
-------------------------------------------------- min heapify 
小根堆:
[13, 27, 38, 40, 76, 65, 97, 49, 99]
-------------------------------------------------- sort heap 
堆排序:
[99, 97, 76, 65, 49, 40, 38, 27, 13]

2. heapq

参考这里 3

import heapqa = [49, 38, 65, 97, 76, 13, 27, 40, 99]
print(f"{'排序前':20}: {a}")print('-' * 50 + ' min heapify ')
heapq.heapify(a)
print(f"{'小根堆':20}: {a}")print('-' * 50 + ' min heapify ')
newa = [(i, a[i]) for i in range(len(a))]
heapq.heapify(newa)
print(f"{'新小根堆':20}: {newa}")
minheap = list()
while newa:_, s = heapq.heappop(newa)print(f"_, s: {_}, {s}")minheap.append(s)
print(f"{'小根堆':20}: {minheap}")

输出信息如下所示:

排序前                 : [49, 38, 65, 97, 76, 13, 27, 40, 99]
-------------------------------------------------- min heapify 
小根堆                 : [13, 38, 27, 40, 76, 65, 49, 97, 99]
-------------------------------------------------- min heapify 
新小根堆                : [(0, 13), (1, 38), (2, 27), (3, 40), (4, 76), (5, 65), (6, 49), (7, 97), (8, 99)]
_, s: 0, 13
_, s: 1, 38
_, s: 2, 27
_, s: 3, 40
_, s: 4, 76
_, s: 5, 65
_, s: 6, 49
_, s: 7, 97
_, s: 8, 99
小根堆                 : [13, 38, 27, 40, 76, 65, 49, 97, 99]

参考链接

#todo:
关于 Python 标准库 heapq 的 大根堆/最大堆的 API~


  1. 浅谈大根堆,小根堆,以及堆排序(python)实现 ↩︎

  2. Python 堆排序 ↩︎

  3. python用heapq模块构建大根堆 ↩︎ ↩︎

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/51236.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

百度23Q2财报最新发布:营收利润加速增长,AI+生态战略渐显规模

百度集团-SW(9888.HK)Q2财报已于2023/08/22(美东)盘前发布&#xff0c;二季度百度集团整体收入实现341亿元&#xff0c;同比增长15%;归属百度的净利润(non-GAAP)达到80亿元&#xff0c;同比增长44%。营收和利润双双实现大幅增长&#xff0c;超市场预期。其中&#xff0c;百度核…

数学建模-常见算法(3)

KMP算法&#xff08;Knuth-Morris-Pratt算法&#xff09; KMP算法是一种用于字符串匹配的算法&#xff0c;它的时间复杂度为O(mn)。该算法的核心思想是在匹配失败时&#xff0c;利用已经匹配的信息&#xff0c;减少下一次匹配的起始位置。 def kmp(text, pattern): n len(…

【框架】SpringBoot数组传参问题

方式一 前端以字符串形式传递idList&#xff0c;采用逗号拼接&#xff0c;后端直接使用list接收 // 前端代码 form: {otherParam: ,idList: [id1,id2].join(,) }//后端代码 // 在后端接收idList时&#xff0c;直接使用List<T> 就可以接收前端字符串&#xff08;默认使用…

基于乌燕鸥算法优化的BP神经网络(预测应用) - 附代码

基于乌燕鸥算法优化的BP神经网络&#xff08;预测应用&#xff09; - 附代码 文章目录 基于乌燕鸥算法优化的BP神经网络&#xff08;预测应用&#xff09; - 附代码1.数据介绍2.乌燕鸥优化BP神经网络2.1 BP神经网络参数设置2.2 乌燕鸥算法应用 4.测试结果&#xff1a;5.Matlab代…

课程项目设计--项目建立--宿舍管理系统--springboot后端

前要 项目设计–宿舍管理系统 文章目录 项目建立导入依赖配置文件配置目录结构config配置mybatis-plusswagger 生成实体、mapper和servicebaseEntity统一响应实例响应码接口响应码接口实现统一响应result统一分页响应 项目建立 太长了&#xff0c;修改一下 导入依赖 暂时先加…

深入浅出理解相机标定原理

重要说明&#xff1a;本文从网上资料整理而来&#xff0c;仅记录博主学习相关知识点的过程&#xff0c;侵删。 一、参考资料 微信公众号&#xff1a;计算机视觉life 专栏&#xff1a;#相机标定 Camera Calibration 张正友标定法-完整学习笔记-从原理到实战 二、相机标定相…

软考高级系统架构设计师系列论文八十一:论行业应用软件系统的开发规划

软考高级系统架构设计师系列论文八十一:论行业应用软件系统的开发规划 一、摘要二、正文三、总结一、摘要 本文通过地震基本参数快速获取与发布系统论述了行业应用软件系统的开发规划。本人去年有幸参加了《地震基本参数快速获取与发布系统的研制》项目的开发,该系统按功能被…

文件内容搜索工具 - Python实现

在本篇文章中&#xff0c;我们将介绍如何使用 wxPython 库创建一个简单的文件搜索工具。这个工具允许用户选择一个文件夹&#xff0c;并在该文件夹中的所有 .py 文件中查找指定的文字&#xff0c;并显示匹配的位置。 C:\pythoncode\blog\searchwordinpyfile.py 代码实现 我们首…

Android 场景Scene的使用

Scene 翻译过来是场景&#xff0c;开发者提供起始布局和结束布局&#xff0c;就可以实现布局之间的过渡动画。 具体可参考 使用过渡为布局变化添加动画效果 大白话&#xff0c;在 Activity 的各个页面之间切换&#xff0c;会带有过渡动画。 打个比方&#xff0c;使用起来类似…

Launcher3开发注意事项

平台 本文以展锐 Android10平台为例。 编译 编译时用 make Launcher3QuickStep -j4 &#xff0c;而不是 make Launcher3 -j4 界面结构 Launcher.java 对应布局 launcher.xml 当前界面 Workspace&#xff0c; CellLayout 是单一页。 控制应用图标隐藏 复写AppFilte…

点亮社交新篇章:探索 WeTalk 新增的头像与群聊功能

目录 引言&#xff1a; 引入头像功能&#xff1a; 头像功能的优势&#xff1a; 引入群聊功能&#xff1a; 群聊功能的优势&#xff1a; 引入头像功能&#xff1a; 查看头像&#xff1a; ​编辑 上传头像&#xff1a; 引入群聊功能&#xff1a; 创建群聊&#xff1a…

1. Java基础知识介绍

文章目录 1. Java基础知识介绍1. 简单输入输出1.1 输入1.2 输出 2. 数据类型2.1 基本数据类型2.2 引用数据类型 3. 函数4. 类基础知识5. 小结 1. Java基础知识介绍 1. 简单输入输出 在Java编程中&#xff0c;我们经常需要与用户进行交互&#xff0c;以获取输入并输出结果。Ja…

万字长文,YOLOv8 yaml 文件解析 | 一文搞定 YOLOv8 分类任务,检测任务,分割任务,关键点任务

之前写过一篇 YOLOv5/v7的 yaml 文件解析,大家反馈都不错,这篇主要介绍 YOLOv8 的 yaml 文件, 其实原本前几个版本的 YOLOv8 的 yaml 文件和 v5v7 的 yaml 一样的,但是更新了很多版之后,有了挺大的改变, 并且 YOLOv8 这个项目支持的算法和任务很多,所以这个 yaml 文件…

nginx文件配置

在部署前后端分离项目时&#xff0c;当前端和后端不在一个服务器上时&#xff0c;需要在前端服务器上下载nginx并配置 #hkdp-front-test 前端服务器 xxx.xxx.x.69 前端项目端口号9528&#xff0c;监听文件夹 /home/apps/vue/hkdp-manager 配置如下 server{ …

LLVM编译报错解决:collect2: fatal error: ld terminated with signal 9 [Killed]

LLVM 编译安装 克隆代码到本地 git clone https://github.com/llvm/llvm-project.git # 需要时间比较长 如果不需要做额外的操作可以只克隆最新的commit git clone --depth 1 https://github.com/llvm/llvm-project.git配置编译选项 cd llvm-project cmake -S llvm -B build…

八月更新 | CI 构建计划触发机制升级、制品扫描 SBOM 分析功能上线!

点击链接了解详情 这个八月&#xff0c;腾讯云 CODING DevOps 对持续集成、制品管理、项目协同、平台权限等多个产品模块进行了升级改进&#xff0c;为用户提供更灵活便捷的使用体验。以下是 CODING 新功能速递&#xff0c;快来看看是否有您期待已久的功能特性&#xff1a; 01…

一个pdf文件分割成两个

# -- coding: utf-8 --** import PyPDF2 # 打开原始PDF文件 # with open(zhongguojinxiandaishi.pdf, rb) as pdf_file: # pdf_reader PyPDF2.PdfReader(pdf_file) # num_pages len(pdf_reader.pages) # # # 确定分割点&#xff08;例如&#xff0c;将页面一分为二&#xff0…

RabbitMq-3入门案例

rabbitmq入门 1.生产者&#xff08;服务提供方&#xff09; //依赖<dependencies> <!-- rabbitmq客户端依赖--><dependency><groupId>com.rabbitmq</groupId><artifactId>amqp-client</artifactId><version>5.8.0<…

element-ui 下拉框选择器selete多选时,单行显示所选内容

1.只需重写 el-select 原生样式 .el-select__tags {flex-wrap: inherit !important;overflow-x: auto !important; }特别注意&#xff1a;重写原生样式时&#xff0c;去掉当前 style 的 scoped 或者可以通过该穿透去实现 ::v-deep .el-select__tags {flex-wrap: inherit !imp…

什么是链表,前端如何理解链表

一、什么是链表 多个元素存储的列表链表中的元素在内存中不是顺序存储的&#xff0c;而是通过“next”指针联系在一起的。 JS中的原型链 原理就是 链表结构 链表结构 {key: "A",next: {key: "B",next: {key: "C",next: null}} } //原型链 //对…