数据结构 | 堆

news2024/12/23 18:02:17

本文简要总结堆的概念。

更新: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 + 1
            print(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')
                break
            if 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 + 1
                print(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 = child
                print(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')
                break

    return arr

def sortheap(arr, end):
    for i in range(end, 0, -1):
        arr[0], arr[i] = arr[i], arr[0]
        maxheap(arr, i-1)

    return arr

if __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 heapq

a = [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 + 1
            if child > end:
                break
            if child-1 >= start and arr[child] > arr[child-1]:
                child = child-1
            if arr[root] > arr[child]:
                arr[root], arr[child] = arr[child], arr[root]
                root = child
            else:
                break
    return arr

def 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 arr

if __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 heapq

a = [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.coloradmin.cn/o/903062.html

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

相关文章

(排序) 剑指 Offer 45. 把数组排成最小的数 ——【Leetcode每日一题】

❓ 剑指 Offer 45. 把数组排成最小的数 难度&#xff1a;中等 输入一个非负整数数组&#xff0c;把数组里所有数字拼接起来排成一个数&#xff0c;打印能拼接出的所有数字中最小的一个。 示例 1: 输入: [10,2] 输出: “102” 示例 2: 输入: [3,30,34,5,9] 输出: “3033459”…

不是说嵌入式是风口吗,那为什么工作还那么难找?

最近确实有很多媒体、机构渲染嵌入式可以拿高薪&#xff0c;这在行业内也是事实&#xff0c;但前提是你有足够的竞争力&#xff0c;真的懂嵌入式。 时至今日&#xff0c;能做嵌入式程序开发的人其实相当常见&#xff0c;尤其是随着树莓派、Arduino等开发板的普及&#xff0c;甚…

游戏找不到msvcr100.dll解决方法,常见的三种解决方法

在计算机领域&#xff0c;msvcr100.dll是一个非常重要的动态链接库文件。它是Microsoft Visual C 2010 Redistributable的一部分&#xff0c;用于支持Visual Studio 2010的开发环境。然而&#xff0c;在某些情况下&#xff0c;msvcr100.dll可能会出现问题&#xff0c;导致程序无…

Centos7内存高|查看占用内存命令

Centos7查看磁盘和CUP统计信息iostat命令 Centos7内存高|查看占用内存命令 docker实战(一):centos7 yum安装docker docker实战(二):基础命令篇 docker实战(三):docker网络模式(超详细) docker实战(四):docker架构原理 docker实战(五):docker镜像及仓库配置 docker实战(六…

Docker自学:利用FastAPI建立一个简单的web app

环境配置&#xff1a;下载Docker Desktop 文件一&#xff1a;main.py from typing import Unionfrom fastapi import FastAPIimport uvicornapp FastAPI()app.get("/") def read_root():return {"Hello": "World"}app.get("/items/{item…

跟着NC学作图 | 使用python绘制折线图

写在前面 今天分享一篇使用Python绘制折线图的教程&#xff0c;在我们前提的教程中&#xff0c;关于使用R语言绘制折线图的教程也很少&#xff0c;跟着PC学作图 | 小提琴图Tufte箱形图折线图的绘制教程也只有相关一部分。 Python自己也是一直在学习&#xff0c;那么也就顺带分…

透视俄乌网络战之一:数据擦除软件

数据擦除破坏 1. WhisperGate2. HermeticWiper3. IsaacWiper4. WhisperKill5. CaddyWiper6. DoubleZero7. AcidRain8. RURansom 数据是政府、社会和企业组织运行的关键要素。数据擦除软件可以在不留任何痕迹的情况下擦除数据并阻止操作系统恢复摧&#xff0c;达到摧毁或目标系统…

排名前 6 位的数学编程语言

0 说明 任何对数学感兴趣或计划学习数学的人&#xff0c;都应该至少对编程语言有一定的流利程度。您不仅会更有就业能力&#xff0c;还可以更深入地理解和探索数学。那么你应该学习什么语言呢&#xff1f; 1.python 对于任何正在学习数学的人来说&#xff0c;Python都是一门很棒…

Linux 线程并发运行

一、并发与并行 并行&#xff1a;两个线程在同一时刻同时执行&#xff0c;需要有两个处理器。 并发&#xff1a;两个线程在同一时刻交替执行&#xff0c;只有一个处理器。 并行是一种特殊的并发。 二、线程并发运行 代码如下&#xff1a; 代码分析&#xff1a; 主函数中第…

Excel/PowerPoint柱状图条形图负值设置补色

原始数据&#xff1a; 列1系列 1类别 14.3类别 2-2.5类别 33.5类别 44.5 默认作图 解决方案 1、选中柱子&#xff0c;双击&#xff0c;按如下顺序操作 2、这时候颜色会由一个变成两个 3、对第二个颜色进行设置&#xff0c;即为负值的颜色 条形图的设置方法相同

智能记账分享,轻松记录、分析和保存收支明细

在现代生活中&#xff0c;财务管理变得越来越重要。要想清晰地了解个人或家庭的财务状况&#xff0c;记录、分析和保存收支明细是必不可少的任务。现在&#xff0c;我们为你带来了一款智能记账分享工具&#xff0c;让你轻松记录、分析和保存收支明细 首先&#xff0c;我们要打…

一文带你了解如何在Java中操作Redis

文章目录 前言一、 Redis客户端简介1. Redis客户端分类2. Spring 整合 Redis 的两种方式 二、 使用 Jedis 操作 Redis1. Jedis的maven坐标2. 使用Jedis操作Redis的步骤3. Jedis 操作 Redis 示例 三、 使用 Spring Data Redis 操作 Redis1. Spring Data Redis 的 maven 坐标2. s…

【C语言】写一个程序,输入数量不确定的【0,9】范围内的整数,统计每一种数字出现的次数,输入-1表示结束

题目 写一个程序&#xff0c;输入数量不确定的【0,9】范围内的整数&#xff0c;统计每一种数字出现的次数&#xff0c;输入-1表示结束 代码 #include<stdio.h> int main() {int x;int i;int a[10];for(i0; i<10; i){//初始化数组 a[i] 0;}scanf("%d",&am…

Unity VR:XR Interaction Toolkit 输入系统(Input System):获取手柄的输入

文章目录 &#x1f4d5;教程说明&#x1f4d5;Input System 和 XR Input Subsystem&#xff08;推荐 Input System&#xff09;&#x1f4d5;Input Action Asset⭐Actions Maps⭐Actions⭐Action Properties&#x1f50d;Action Type (Value, Button, Pass through) ⭐Binding …

ARM 配置晶振频率

文章目录 前言串口乱码问题定位内核修改晶振频率uboot 修改晶振频率番外篇 前言 上篇文章《ARM DIY 硬件调试》介绍了 DIY ARM 板的基础硬件焊接&#xff0c;包括电源、SOC、SD 卡座等&#xff0c;板子已经可以跑起来了。 但是发现串口乱码&#xff0c;今天就来解决串口乱码问…

Java-数组

什么是数组 数组&#xff1a;可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。 在java中&#xff0c; 数组中存放的元素其类型相同数组的空间是连在一起的每个空间有自己的编号&#xff0c;起始位置的编号为0&#xff0c;即数组的下标。 数组的创建及初始化 数…

FL Studio21最新版本升级中文语言教程

FL中文提供了跨版本升级&#xff0c;用户可以通过下载21入门版或其他非完整版的版本&#xff0c;升级为更高的版本&#xff0c;解锁更多的插件&#xff0c;下面为大家介绍在下载升级服务后&#xff0c;如何进行升级版本。 FL Studio 21 Win-安装包下载如下:https://wm.makeding…

CTF工具隐写分离神器Binwalk安装和详细使用方法

binwalk安装 1.Binwalk 介绍&#xff1a;2.Binwalk下载&#xff1a;3.Windows安装&#xff1a;4.Linux下载安装&#xff1a;5.Binwalk基本用法&#xff1a;6.Binwalk案例展示&#xff1a;7.Binwalk总结&#xff1a; 1.Binwalk 介绍&#xff1a; Binwalk 是用于搜索给定二进制镜…

Java之线程的状态

文章目录 一、线程状态二、代码演示1. Threadstate 类2. SleepUtils 类3. 运行示例 三、参考资料 一、线程状态 Java线程在运行的生命周期中可能处于下图所示的6种不同的状态,在给定的一个时刻线程只能处于其中的一个状态。 Java线程的状态 状态名称说明NEW初始状态&#xff0…