【数据结构】4.5优先队列与堆

于 2023-07-21 10:56:05 发布
阅读量231 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/serendipity_lz/article/details/128653622
版权

目录

1、优先队列的定义

2、优先队列的实现方式：

3、堆的两个特性：

4、堆的ADT

5、堆的实现

  （1）插入操作：

  （2）删除操作：队列中的重要级别最高的那个元素

  （3）堆的建立

6、堆的应用

  （1）堆排序

  （2）Huffman树的建立

 7、完整代码

1、优先队列的定义

        优先队列：按照优先级与重要性来组织对象的一种ADT。
        一种特殊的“队列”，取出元素的顺序是依照元素的优先权（关键字）大小，而不是元素进入队列的先后顺序。
        生活中的例子：在多用户的环境中，操作系统调度程序必须决定在若干进程中运行哪个进程；发话到打印机中的若个作业可能在某些时候并不想按照先来先打印的方式运行。

优先队列需要的操作：
        1、插入: 增加一个带有重要级别的元素，插入到队列中的位置并不在意
        2、删除: 队列中的重要级别最高的那个元素
        3、获得头元素: 队列中的重要级别最高的那个元素

对比一般队列：
1、插入：增加一个元素，这个元素被插入到队列中队尾
2、删除：剩除一个队列中队头的那个元素
3、获得头元素：获得队列中队头的那个元素

2、优先队列的实现方式：

1、数组 :
        插入 — 元素总是插入尾部：Θ( 1 )
        删除 — 查找最大（或最小）关键字 ：Θ ( n )
        从数组中删去找到的结点，同时需要移动元素：O( n )
2、链表:
        插入 — 元素总是插入链表的头部：Θ( 1 )
        删除 — 查找最大（或最小）关键字：Θ ( n )
        删去找到的结点：Θ（1）
3、有序数组:
        插入 — 找到合适的位置：O( n ) 或 O(log2 n )
        移动元素并插入：O( n )
        删除 — 删去最后一个元素：Θ( 1 )
4、有序链表:
        插入 — 找到合适的位置：O( n )
        插入元素：Θ( 1 )
        删除 — 删除首元素或最后元素：Θ( 1 )
5、考虑用树来实现：
        如果用二叉检索树（不采用AVL平衡），时间复杂度为树的高度，但对于每次都要删除/插入最大的树的操作，使得树平衡性被破坏，效率降低。
        在对优先队列操作时，需要更关注的是删除最大值（插入可以次位考虑）。因此考虑将最大值放在树根处，根据二叉树的递归定义，规定任何结点都是以其为根结点的树中的最大值，删除时只需要去掉树根结点即可→堆。

3、堆的两个特性：

        1、结构性：完全二叉树，因此可以用数组代替链表来实现；
        2、有序性：任一结点的关键字是其子树所有结点的最大值（或最小值），由于二叉树的递归定义，满足任意结点的关键值大于其左右子结点即可。对根元素的访问是最快的获取速度，因此堆能够快速的找出重要级别最高的元素。
        ●  最大堆（MaxHeap），也称“大顶堆”：任意一个结点的键值都大于或等于其任意一个子结点存储的值（是以该结点为根结点的二叉树的最大值）
        ●  最小堆（MinHeap），也称“小顶堆”：任意一个结点的键值都小于或等于其任意一个子结点存储的值（是以该结点为根结点的二叉树的最小值）

         注意：从根结点到任意结点的路径，始终满足有序性（一路从大到小/从小到大）

4、堆的ADT

        下文以最大堆为例说明

void insert(E item); //将元素item插入最大堆MaxHeap
E findMax(); //获取MaxHeap中最大元素
E deleteMax(); //删除MaxHeap中最大元素(优先级最高)并返回
boolean isFull(); //判断最大堆MaxHeap是否已满
boolean isEmpty(); //判断最大堆MaxHeap是否为空

5、堆的实现

        相关参数：

private int currentSize; //当前堆的大小,也是当前存放的末尾元素位置
private E[] array; //堆数组

  （1）插入操作：

步骤：

        Step1 将要插入的元素插入到堆中的最后一个位置
        Step2 若当前结点为根结点（基准情形1）则返回
        Step3 比较当前元素与其父结点的重要性：
                1、若满足堆的有序性（基准情形2）则返回
                2、若不满足则将当前元素和其父元素交换，重复Step2-3

此操作的时间复杂度为：T (N) = O ( log N )

        代码实现：

public void insert(E item) {
    if (isFull()) {
        System.out.println("heap is full!");
        return;
    }
    array[++currentSize] = item; //先自增再存放。将item放在数组最后
    int temp = currentSize;
    while ((temp != 1) && (array[temp].compareTo(array[getParent(temp)]) > 0)) {
    //如果非根节点且比父结点的键值大则交换
    swap(array, temp, getParent(temp));
    temp = getParent(temp);//始终定位在插入的元素位置
    }
}

        代码优化：过滤结点，比交换数据要快。

public void insert(E item) {
    if (isFull()) {
        System.out.println("heap is full!");
        return;
    }
    int temp = ++currentSize;//temp指向当前要插入的位置
    while ((temp != 1) && (item.compareTo(array[getParent(temp)]) > 0)) {
        array[temp] = array[getParent(temp)]; //如果非根节点且插入元素比父结点的键值大,则向下过滤父结点
        temp = getParent(temp);
    }
    array[temp] = item; //将item插入
}

  （2）删除操作：队列中的重要级别最高的那个元素

步骤：

        Step1 用临时变量保存根结点（优先级最高的）的元素并删除
        Step2 将堆最末尾的元素填补到根结点位置
        Step3 若填补的结点为叶结点（基准情形1）则返回
        Step4 将填补的结点与它的孩子结点进行重要性的比较
                1、若满足堆的有序性（基准情形2）则返回
                2、若不满足则将当前元素和其重要级别高的孩子结点交换，重复Step3-4
此操作的时间复杂度为：T (N) = O ( log N )

public E deleteMax() {
    if (isEmpty()) {
        System.out.println("heap is empty!");
        return null;
    }
    E maxItem = array[1];
    E itemFill = array[currentSize--];//用最大堆中最后一个元素从根结点开始向上过滤下层结点
    //删除了堆中唯一的元素的情况：此时currentSize==0,下述代码也可以满足该情况,无需单独判断
    int tempFill = 1;
    while (!isLeaf(tempFill)) { //不是叶子结点,则必定有左子结点
        int child = tempFill * 2; //child定位到填补位置的左子结点处
        if ((child != currentSize) && (array[child].compareTo(array[child + 1]) < 0))
            child++; //若有右结点,child指向左右子结点的较大者
        if (itemFill.compareTo(array[child]) < 0) {
            array[tempFill] = array[child]; //若不满足有序性(itemFill比左右子结点的较大者小),将左右子结点中的较大者向上过滤
            tempFill = child; //tempFill始终指向要填补的位置,下移一层
        } else
            break;
    }
    array[tempFill] = itemFill;
    return maxItem;
}

  （3）堆的建立

        建立最大堆：将已经存在的N个元素按最大堆的要求存放在一个一维数组中
方法1：
        通过插入操作，将N个元素一个个相继插入到一个初始为空的堆中去，其时间代价最大为O(N log N)。
方法2：在线性时间复杂度下建立最大堆
        先将N个元素按输入顺序存入，满足完全二叉树的结构特性
        再调整各结点位置，以满足最大堆的有序特性：
[思想]
        删除操作中调整的思想核心：已知该结点左右子树均为堆，如何调整该结点的位置使以其为根结点的二叉树为堆？→和左右子结点比较，将三者中最大的向上过滤。
        因此，将该思想用于调整无序的序列中：从满足有序性的堆开始（基准情形），向上对其根结点进行调整。
        叶结点即有序的堆，而对于完全二叉树，叶结点近乎占了一半，所以对于初始化的数组来说，其中有一半以上的元素满足堆序。

[步骤]
        Step1 将N个元素按输入顺序存入数组中，修改相应的参数值。

        Step2 从从非叶子结点开始从右到左,从下到上调整直至根结点（具体实现与删除结点是类似）

        此操作的线性时间复杂度T(n)=O(n)

        代码实现：

public MaxHeap(E[] array) {
    this.array = (E[]) new Object[array.length + 1];
    for (int i = 0; i < array.length; i++) {
        this.array[i + 1] = array[i];
    }
    currentSize = array.length;
    buildHeap();
}
public void buildHeap() {
    for (int i = currentSize / 2; i > 0; i--) { 
        //从非叶子结点开始从右到左,从下到上调整直至根结点
        int temp = i; //记录当前调整元素应放置的位置
        E item = array[temp]; //临时存储下当前位置的元素值
        while (!isLeaf(temp)) { //不是叶子结点,则必定有左子结点
            int child = temp * 2; //child定位到填补位置的左子结点处
            if ((child != currentSize) && (array[child].compareTo(array[child + 1]) < 0))
                child++; //若有右结点,child指向左右子结点的较大者
            if (item.compareTo(array[child]) < 0) {
                array[temp] = array[child]; //若不满足有序性(itemFill比左右子结点的较大者小),将左右子结点中的较大者向上过滤
                temp = child; //tempFill始终指向要填补的位置,下移一层
            } else
                break;
        }
        array[temp] = item;
    }
}

6、堆的应用

  （1）堆排序

        依次输出根结点元素并删除（其中需要调整操作）
        时间复杂度：O ( N )+O ( (N-1) logN ) = O ( N log N )

public void heapSort() {
    while (currentSize != 0) {
        System.out.print(deleteMax()+ " ");
    }
}

  （2）Huffman树的建立

        适用频繁增加删除的情况，具体见【数据结构】4.3Huffman树。

 7、完整代码

public class MaxHeap<E extends Comparable<E>> {
    private static final int DEFAULT_CAPACITY = 10;//默认大小
    private int currentSize;//当前堆的大小,也是当前存放的末尾元素位置
    private E[] array;//堆数组

    //constructor部分,(考虑到表达的精简性,0不存储,从1开始存储元素)。
    public MaxHeap() {
        this.array = (E[]) new Object[DEFAULT_CAPACITY + 1];
        currentSize = 0;
    }

    public MaxHeap(int maxSize) {
        this.array = (E[]) new Object[maxSize + 1];
        currentSize = 0;
    }

    public MaxHeap(E[] array) {
        this.array = (E[]) new Object[array.length + 1];
        for (int i = 0; i < array.length; i++) {
            this.array[i + 1] = array[i];
        }//从1开始算
        currentSize = array.length;
        buildHeap();
    }

    public void insert(E item) {
        if (isFull()) {
            System.out.println("heap is full!");
            return;
        }

        /*方法1
        array[++currentSize] = item; //先自增再存放。将item放在数组最后
        int temp = currentSize;
        while ((temp != 1) && (array[temp].compareTo(array[getParent(temp)]) > 0)) {
            //如果非根节点且比父结点的键值大则交换
            swap(array, temp, getParent(temp));
            temp = getParent(temp);//始终定位在插入的元素位置
        }
        */

        //方法2,过滤结点,比交换数据要快:T(N)=O(log N)
        int temp = ++currentSize;//temp指向当前要插入的位置
        while ((temp != 1) && (item.compareTo(array[getParent(temp)]) > 0)) {
            array[temp] = array[getParent(temp)]; //如果非根节点且插入元素比父结点的键值大,则向下过滤父结点
            temp = getParent(temp);
        }
        array[temp] = item; //将item插入

    }

    public E deleteMax() {
        if (isEmpty()) {
            System.out.println("heap is empty!");
            return null;
        }
        E maxItem = array[1];
        E itemFill = array[currentSize--];//用最大堆中最后一个元素从根结点开始向上过滤下层结点
        //删除了堆中唯一的元素的情况：此时currentSize==0,下述代码也可以满足该情况,无需单独判断
        int tempFill = 1;
        while (!isLeaf(tempFill)) { //不是叶子结点,则必定有左子结点
            int child = tempFill * 2; //child定位到填补位置的左子结点处
            if ((child != currentSize) && (array[child].compareTo(array[child + 1]) < 0))
                child++; //若有右结点,child指向左右子结点的较大者
            if (itemFill.compareTo(array[child]) < 0) {
                array[tempFill] = array[child]; //若不满足有序性(itemFill比左右子结点的较大者小),将左右子结点中的较大者向上过滤
                tempFill = child; //tempFill始终指向要填补的位置,下移一层
            } else
                break;
        }
        array[tempFill] = itemFill;
        return maxItem;
    }

    public E findMax() {
        return array[1];
    }

    public void buildHeap() {
        for (int i = currentSize / 2; i > 0; i--) { //从非叶子结点开始从右到左,从下到上调整直至根结点
            int temp = i; //记录当前调整元素应放置的位置
            E item = array[temp]; //临时存储下当前位置的元素值
            while (!isLeaf(temp)) { //不是叶子结点,则必定有左子结点
                int child = temp * 2; //child定位到填补位置的左子结点处
                if ((child != currentSize) && (array[child].compareTo(array[child + 1]) < 0))
                    child++; //若有右结点,child指向左右子结点的较大者
                if (item.compareTo(array[child]) < 0) {
                    array[temp] = array[child]; //若不满足有序性(itemFill比左右子结点的较大者小),将左右子结点中的较大者向上过滤
                    temp = child; //tempFill始终指向要填补的位置,下移一层
                } else
                    break;
            }
            array[temp] = item;
        }
    }


    public void print() {
        for (int i = 1; i <= currentSize; i++) {
            System.out.print(array[i] + " ");
        }
    }

    public void heapSort() {
        while (currentSize != 0) {
            System.out.print(deleteMax()+ " ");
        }
    }

    public boolean isFull() {
        return currentSize == array.length - 1;
    }

    public boolean isEmpty() {
        return currentSize == 0;
    }

    private int getParent(int i) {
        return i / 2;
    }

    private boolean isLeaf(int i) {
        return i * 2 > currentSize;
    }

    private int getLeftSon(int i) {
        return i * 2;
    }

    private void swap(E[] array, int x, int y) {
        E temp = array[y];
        array[y] = array[x];
        array[x] = temp;
    }

    public static void main(String[] args) {
        Integer[] test = {1, 2, 6, 4, 5, 7, 3};
        MaxHeap<Integer> maxHeap = new MaxHeap<Integer>(test);
        maxHeap.print();
        maxHeap.deleteMax();
        System.out.println();
        System.out.println("delete 7:");
        maxHeap.print();
        maxHeap.insert(7);
        System.out.println();
        System.out.println("insert 7:");
        maxHeap.print();
        System.out.println();
        System.out.println("heapsort: ");
        maxHeap.heapSort();
    }

}
一汀Yvette
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
优先队列详解/C++
2020
08-09 1万+
优先队列 1.概念:什么是优先队列呢?在优先队列中，元素被赋予优先级，当访问元素时，具有最高级优先级的元素先被访问。即优先队列具有最高级先出的行为特征。它可以说是队列和排序的完美结合体，不仅可以存储数据，还可以将这些数据按照我们设定的规则进行排序。 2.定义:优先队列在头文件#include <queue>中；其声明格式为：priority_queue <int> a...
java简易优先队列（小顶堆）
See what you want to see
03-21 292
java简易优先队列（小顶堆） class Heap{ private int[] heap; private int size; public Heap(int n) { heap = new int[n + 1]; size = 0; } public void offer(int num) { int father = ((size - 1) >> 1), index = size; heap[index] = num; while (father &g
优先级队列及小顶堆排序
法相的博客
04-28 778
优先级队列及小顶堆排序实现
c++优先队列（priority_queue）小顶堆 大顶堆
meiyongyue的博客
07-16 805
include <queue> # include <functional> //greater<> //定义 priority<Type,Container,Funstional>可缺省后面那个参数，第二个为保存数据的容器，第三个为元素比较的方式 priority_queue < int > pq;//缺省，默认容器vector，比较方式operator<,即大顶堆，队头元素最大 priority_queue < string > q;
类包装的优先队列 小顶堆实现
Kblacksmith的博客
01-04 567
最近实习时比较了一下链表实现的优先队列和用堆实现的优先队列时间的差距。。发现数据大了后差的真是超多。。 数据量到了100000后前者需要25秒左右的时间，而后者只需0.03秒左右。（当然与机房实习时的机子烂也有关系）#include <iostream> #include <algorithm> using namespace std; template<class T> class Vector
优先队列 小顶堆，大顶堆
u013385018的专栏
06-21 1871
堆定义 定义： 1、堆是一颗完全二叉树； 2、堆中的某个结点的值总是大于等于（最大堆）或小于等于（最小堆）其孩子结点的值。 3、堆中每个结点的子树都是堆树。
刷题算法提高阶段-数据结构6
最新发布
12-22
2. **堆属性**: 堆是一种特殊的树形数据结构，满足堆性质：父节点的键值总是大于或等于（最大堆）或小于或等于（最小堆）其子节点的键值。在Treap中，每个节点的优先级遵循堆的性质，但优先级与键值无关。 3. **...
数据结构与算法java中文
11-05
### 数据结构与算法Java中文知识点概述 #### 一、Java与面向对象程序设计 ##### 1.1 Java语言基础知识 **1.1.1 基本数据类型及运算** - **基本数据类型**：Java提供了八种基本数据类型，包括四种整型（byte、...
数据结构学习总框架（精华版）.pdf
02-02
- 实现：采用优先队列优化搜索过程。 **6.3 案例三：数据压缩算法** - 介绍：霍夫曼编码，用于无损数据压缩。 - 实现：构建霍夫曼树，生成最优编码方案。 #### 七、总结 通过本文的学习，我们了解了数据结构的基本...
POJ 2051 优先队列/小顶堆O(klog(n))轻松实现
Baileys0530的专栏
07-10 996
#include typedef struct node { int ID; int period; long long time; }Node; Node heap[1005]; static int hlength; int down(int p) { int q = 2 * p; Node a = heap[p]; while(q <= hlength) { if(q <
优先级队列: 搞懂大顶堆和小顶堆 c++
qq_40286920的博客
07-28 2569
优先级队列是队列的一种，可以按照自定义的方式对队列中的数据进行排序。
优先级队列(堆)
m0_72161237的博客
05-27 1274
1️⃣小堆：按完全二叉树的顺序存储方式存储在一个一维数组Ki = K2i + 2孩子节点大于父亲节点）将根节点最大的堆叫做最大堆或大根堆3️⃣堆的性质：堆中某个节点的值总是不大于或不小于其父节点的值；堆总是一棵完全二叉树（采用顺序方式存储）
【ADT】第六章 堆—优先队列
CstomRita的博客
08-26 380
之前在链表ADT中涉及到了队列，LInkedList通过双链表实现了队列先进先出的功能 此次提出一个优先队列的概念，它依旧满足队列一端入队一端出队的原则，唯一的区别在于出列的工作是找出、返回并删除优先队列中的最小值 优先队列中的操作仅仅限于插入和最小值，不能排序、也不能find（非最小值） 一次insert(入队)的平均为O(1)，删除最小元(出队)平均时间O(logN) 对优先队列的实现...
优先队列——大顶堆和小顶堆
YECHANG1450的博客
11-06 2454
首先了解 PriorityQueue（优先队列） 是一个基于优先级堆的无界优先级队列，底层实现是一棵完全二叉树 不允许使用 null 元素 不允许插入不可比较的对象，会导致 ClassCastException。 优先级队列是无界的，但是有一个内部容量，默认容量为11，控制着用于存储队列元素的数组大小。它通常至少等于队列的大小。随着不断向优先级队列添加元素，其容量会自动增加 PriorityQueue 线程不安全，想线程安全用 PriorityBlockingQueue 类 PriorityQueue
剑指offer -- 优先级队列/大顶堆，小顶堆
DXT的博客
08-13 657
数据流中的中位数 题目描述 如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。 参考：https://www.nowcoder.com/questionTermi...
堆排序&优先级队列
Mr_Garfield__的博客
02-25 374
堆 1.大根堆：根节点的值都大于或等于子树的值 小根堆: 根节点的值都小于或等于子树的值 堆是完全二叉树 创建一个堆： i）存储： 用顺序表存储 ii）.第一步： 将数据集合存储成完全二叉树 第二步： 调整成堆 #define DataType int void AdjustDown(DataType *a, size_t n, int root) { i...
BUAA 702水题-哈夫曼(小顶堆或者优先队列解决)
crazy_石头的专栏
12-05 955
柯南之合并 描述 测试说明与提交 提交状态 题目设置 Description 柯南发现一个果园，果园中每个果子都有一个记号，有些果子记号相同，于是柯南认为这些果子是犯人传递消息的工具，所以柯南把所有的果子打了下来，而且按果子的不同种类分成了不同的堆。调查完后柯南要把所有的果子合成一堆，送回果园。 　　每一次合并，柯南可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之
数据结构——优先队列与堆
lfm1010123的博客
06-13 959
优先级队列的底层实际上就是利用堆这种数据结构实现的。堆在逻辑上是一颗完全二叉树，而其物理结构却是数组，二叉树中的每个节点对应着数组的下标，树中的第一个节点（根节点）的数组下标为0，树中的最后一个节点不一定为数组的最后一个元素（数组可能没满），而我们学习的堆，分为两种：① 大顶堆：每个节点的值都 >= 其左右孩子节点的值，此外，第一个根节点的值一定是所有堆中其余节点的最大值。 ② 小顶堆：每个节点的值都 .........
数据结构（C语言描述）优先队列
qq_740785701的博客
03-30 3220
1 优先队列的定义 优先队列是一个以集合为基础的抽象数据类型。 优先队列中的每一个元素都有一个优先级。 定义在优先队列上的基本运算如下。 Min(H): 返回优先队列H中具有最下优先级的元素。 Insert(x,H): 将元素x插入优先队列H。 DeleteMin(H): 删除并返回优先队列H中具有最小优先级的元素。 在优先队列中，是按照每个对象的优先级顺序进行的。 2 优先队列的简单实现 所有实现字典的方法都可用于实现优先队列。优先队列中元素的优先级可以看成字典中元素的线性序值。 用有序链表实现优先队列，
理解数据结构：二叉堆与优先队列
"特殊的数据结构-堆.pptx" 堆是一种特殊的数据结构，尤其在计算机科学和算法设计中扮演着重要角色。在给定的文件中，主要讨论了两种类型的堆——最大堆（大根堆）和最小堆（小根堆），以及它们在解决特定问题，如...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值