《数据结构、算法与应用C++语言描述》-优先级队列-大根堆的C++实现

2023-11-30 00:44
文章标签 算法 语言 c++ 实现 应用 数据结构 优先级 队列 描述 大根堆

本文主要是介绍《数据结构、算法与应用C++语言描述》-优先级队列-大根堆的C++实现，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

优先级队列

完整可编译运行代码见：Github::Data-Structures-Algorithms-and-Applications/_25Priority queue

定义

优先级队列（priority queue）是0个或多个元素的集合，每个元素都有一个优先权或值，对优先级队列执行的操作有1）查找一个元素；2）插入一个新元素；3）删除一个元素。与这些操作分别对应的函数是top、push和pop。在最小优先级队列（min priority queue）中，查找和删除的元素都是优先级最小的元素；在最大优先级队列（max priority queue）中，查找和删除的元素都是优先级最大的元素。优先级队列的元素可以有相同的优先级，对这样的元素，查找与删除可以按任意顺序处理。

抽象数据类型

最大优先级队列的抽象数据类型说明如ADT 12-1所示，最小优先级队列的抽象数据类型说明与之类似，只是top的pop函数不同，查找和删除的都是优先级最小的元素。

在这里插入图片描述

堆

定义

定义 12-1 一棵大根树（小根树）是这样一棵树，其中每个节点的值都大于（小于）或等于其子节点（如果有子节点的话）的值。

定义 12-2 一个大根堆（小根堆）既是大根树（小根树）也是完全二叉树。

在大根树或小根树中，节点的子节点个数可以任意，不一定是二叉树。

必须满足是大(小)根树同时是完全二叉树才能称为大(小)根堆。

堆是完全二叉树，具有n个元素的堆的高度为 ⌈ l o g 2 （ n + 1 ） ⌉ \lceil log_2（n+1）\rceil ⌈log2​（n+1）⌉。因此，如果能够在 O ( h e i g h t ) O(height) O(height)时间内完成插入和删除操作，那么这些操作的复杂性为 O ( l o g n ) O(logn) O(logn)。

大(小)根堆使用数组存储。以层序遍历的顺序存储元素。

大根堆的插入

由于大根堆是完全二叉树，所以在插入元素时，一定会在完全二叉树的最后一层的最后一个元素后添加一个节点。插入元素的步骤是新元素插入新节点，然后沿着从新节点到根节点的路径，执行一趟起泡操作，将新元素与其父节点的元素比较交换，直到后者大于或等于前者为止。如下图所示，如果插入元素1，可以将其直接作为节点2的左孩子。但是如果插入元素5，就需要执行起泡操作。

在这里插入图片描述

大根堆的删除

在大根堆中删除一个元素，就是删除根节点的元素。

大根堆使用数组存储，以层序遍历的顺序存储，因此数组存储的第一个节点就是最大元素。删除操作顺序为，首先找到数组存储的最后一个元素，将该元素使用temp变量暂存起来，并删除最后一个元素。然后尝试将temp放到第一个元素，这样不满足大根堆的定义，因此把根元素的左右元素的大者移到根节点。移动后形成一个空位，尝试将temp放到该空位，如果满足该节点元素大于等于其孩子节点元素，那么放置成功，删除操作完成；否则，继续选择空位的左右孩子的大者移动到空位，以此类推，直到找到合适的位置放置temp，删除操作完成。

如图12-4删除图12-3 d)的根节点。

在这里插入图片描述

大根堆的初始化

初始时，要向堆中插入n(n>0)个元素。插入操作所需的总时间为 O ( n l o g n ) O(nlogn) O(nlogn)。也可以用不同的策略在 O ( n ) O(n) O(n)时间内完成堆的初始化。

首先是拿到一个数组，数组的元素按任意顺序。该数组可以转化为一个完全二叉树，需要做的是将完全二叉树转化为大根堆。从最后一个具有孩子的节点开始，如果以这个元素为根的子树是大根堆，则不做操作；如果以这个元素为根的子树不是大根堆，则需要将这个子树调整为大根堆。然后一次检查倒数第二个、倒数第三个子树，直到检查到第一个元素为根的树为止。

代码

template<class T>
void maxHeap<T>::initialize(T *theHeap, int theSize)
{delete [] heap;heap = theHeap;// 数组已经指定了heapSize = theSize;// 从最后一个有孩子节点的节点开始for (int root = heapSize / 2; root >= 1; root--){T rootElement = heap[root];int child = 2 * root; // 当前节点的左孩子节点while (child <= heapSize){// 找到孩子节点中的较大者if (child < heapSize && heap[child] < heap[child + 1])child++;// 如果rootElement大于等于孩子节点的较大者，那么就终止循环if (rootElement >= heap[child])break;// 如果rootElement小于孩子节点的较大者，就在父亲节点放置孩子节点heap[child / 2] = heap[child];child *= 2;// 找到较大孩子节点的孩子节点}// 如果孩子节点的较大者小于rootElement，就将rootElement作为孩子节点的父亲heap[child / 2] = rootElement;}
}

复杂性

在大根堆的初始化程序 initialize函数中，如果元素个数为 n(即theSize=n)，那么for 循环的每次迭代所需时间为 O ( l o g n ) O(logn) O(logn)，迭代次数为 n / 2 n/2 n/2，因此initialize函数的复杂性为 O ( n l o g n ) O(nlogn) O(nlogn)。注意，O表示法提供算法复杂性的上限。实际应用中，initialize的复杂性要比上限 O ( n l o g n ) O(nlogn) O(nlogn)好一些。经过更仔细的分析，我们得出真正的复杂性为 Θ ( n ) Θ(n) Θ(n)。

在 initialize 函数中，while 循环的每一次迭代所需时间为 O ( h i ) O(h_i) O(hi​)，其中 h i h_i hi​是以位置i 为根节点的子树的高度。完全二叉树heap[1：n]的高度为 h = ⌈ l o g 2 ( n + 1 ) ⌉ h=\lceil log_2(n+1)\rceil h=⌈log2​(n+1)⌉。在树的第j层，最多有 2 j − 1 2^{j-1} 2j−1个节点。因此最多有 2 j − 1 2^{j-1} 2j−1个节点具有相同的高度 h i = h − j + 1 h_i=h-j+1 hi​=h−j+1。于是大根堆的初始化时间为:

在这里插入图片描述

因为for循环执行n/2次迭代，所以复杂性为2(n)。将两者综合考虑，得到initialize的复杂性为 Θ ( n ) Θ(n) Θ(n)。

堆与STL

STL的类 priority_queue利用了基于向量的堆来实现大根堆，它允许用户自己制定优先级的比较函数，因此，这个类也可以用于实现小根堆。

代码

main.cpp

/*
Project name :			_25Priority_queue
Last modified Date:		2023年11月29日21点08分
Last Version:			V1.0
Descriptions:			优先级队列——大根堆main函数
*/
#include "maxHeap.h"
int main() {maxHeapTest();return 0;
}

maxHeap.h

/*
Project name :			_25Priority_queue
Last modified Date:		2023年11月29日21点08分
Last Version:			V1.0
Descriptions:			优先级队列——大根堆模板头文件
*/
/*[[nodiscard]]标记符可以用于提示程序员在调用有返回值的函数时不要忘记接收改函数的返回值*/#ifndef _25PRIORITY_QUEUE_MAXHEAP_H
#define _25PRIORITY_QUEUE_MAXHEAP_H
#include "maxPriorityQueue.h"
#include "_1myExceptions.h"
#include "_2myFunctions.h"
#include <iostream>
#include <sstream>
#include <algorithm>
#include <memory>using namespace std;
int maxHeapTest();
template<class T>
class maxHeap : public maxPriorityQueue<T>
{
public:explicit maxHeap(int initialCapacity = 10);~maxHeap() {heap = nullptr;}[[nodiscard]] bool empty() const {return heapSize == 0;}[[nodiscard]] int size() const {return heapSize;}const T& top(){// 返回最大元素，也就是堆顶的值if (heapSize == 0)throw queueEmpty();return heap[1];}void pop();// 向堆中弹出元素void push(const T&);// 向堆中插入元素void initialize(T *, int);// 初始化堆void deactivateArray()// 禁用数组，这个还没搞清楚怎么用{heap = nullptr; arrayLength = heapSize = 0;}void output(ostream& out) const;// 输出大根堆的所有元素
private:int heapSize;       // 存储大根堆中有多少元素int arrayLength;    // 存储大根堆的容量大小T* heap;            // 存储大根堆元素的数组
};template<class T>
maxHeap<T>::maxHeap(int initialCapacity)
{// 构造函数，容量必须>=1if (initialCapacity < 1){ostringstream s;s << "Initial capacity = " << initialCapacity << " Must be > 0";throw illegalParameterValue(s.str());}arrayLength = initialCapacity + 1;heap = new T(arrayLength);heapSize = 0;
}// 向大顶堆中插入元素
template<class T>
void maxHeap<T>::push(const T& theElement)
{// 如果容量不够的话需要增加容量if (heapSize == arrayLength - 1){changeLength1D(heap, arrayLength, 2 * arrayLength);arrayLength *= 2;}// 从叶子节点开始起泡，将元素插入int currentNode = ++heapSize;// 如果编号i不是根节点，则其父节点的编号为[i/2](向下取整)while (currentNode != 1 && heap[currentNode / 2] < theElement){// 父节点小于子节点，不能将元素放到此处heap[currentNode] = heap[currentNode / 2]; // 将父节点放到currentNode出currentNode /= 2;                          // 当前节点的index转移到父节点}// 直到父节点大于等于theElement，将theElement放到当前位置heap[currentNode] = theElement;
}// 删除大顶堆的最大元素
// 在大根堆是二叉树时可以这样弄
template<class T>
void maxHeap<T>::pop()
{// 如果大顶堆元素个数为0，那么抛出queueEmpty异常if (heapSize == 0)throw queueEmpty();// 删除数组中第一个元素，也就是根节点的元素heap[1].~T();// 找到大顶堆的最后一排的最后一个元素T lastElement = heap[heapSize--];// 当前节点与其孩子节点的indexint currentNode = 1,child = 2;while (child <= heapSize){// 找到孩子节点中的较大者if (child < heapSize && heap[child] < heap[child + 1]) // 这里只考虑了两个孩子，因此大根堆是二叉树child++;// 如果lastElement大于等于孩子节点的较大者，就终止循环，说明找到了lastElement可以放置的位置if (lastElement >= heap[child])break;// 如果没找到放置lastElement的位置，就在currentNode放置孩子节点中的较大者heap[currentNode] = heap[child];currentNode = child;// 现在空位就变成了刚刚移动的孩子节点child *= 2;// 其孩子的index就是2倍的child}heap[currentNode] = lastElement;// 如果找到位置了就直接将最后一个元素放置到找到的位置上
}template<class T>
void maxHeap<T>::initialize(T *theHeap, int theSize)
{delete [] heap;// 数组已经指定了heap = theHeap;heapSize = theSize;// 从最后一个有孩子节点的节点开始for (int root = heapSize / 2; root >= 1; root--){T rootElement = heap[root];int child = 2 * root; // 当前节点的左孩子节点while (child <= heapSize){// 找到孩子节点中的较大者if (child < heapSize && heap[child] < heap[child + 1])child++;// 如果rootElement大于等于孩子节点的较大者，那么就终止循环if (rootElement >= heap[child])break;// 如果rootElement小于孩子节点的较大者，就在父亲节点放置孩子节点heap[child / 2] = heap[child];child *= 2;// 找到较大孩子节点的孩子节点}// 如果孩子节点的较大者小于rootElement，就将rootElement作为孩子节点的父亲heap[child / 2] = rootElement;}
}template<class T>
void maxHeap<T>::output(ostream& out) const
{// 输出大顶堆中的所有元素for(T* i = heap + 1; i < heap + heapSize + 1; i++)cout << *i << " ";cout << endl;
}// 重载输出操作符 <<
template <class T>
ostream& operator<<(ostream& out, const maxHeap<T>& x)
{x.output(out); return out;}#endif //_25PRIORITY_QUEUE_MAXHEAP_H

maxHeap.cpp

/*
Project name :			_25Priority_queue
Last modified Date:		2023年11月29日21点08分
Last Version:			V1.0
Descriptions:			优先级队列——大根堆模板源文件
*/
#include "maxHeap.h"using namespace std;int maxHeapTest()
{// test constructor and pushmaxHeap<int> h(3);h.push(10);h.push(20);h.push(5);cout << "Heap size is " << h.size() << endl;cout << "Elements in array order are" << endl;cout << h << endl;h.push(15);h.push(30);cout << "Heap size is " << h.size() << endl;cout << "Elements in array order are" << endl;cout << h << endl;// test top and popcout << "The max element is " << h.top() << endl;h.pop();cout << "The max element is " << h.top() << endl;h.pop();cout << "The max element is " << h.top() << endl;h.pop();cout << "Heap size is " << h.size() << endl;cout << "Elements in array order are" << endl;cout << h << endl;// test initializeint z[10];for (int i = 1; i < 10; i++)z[i] = i;h.initialize(z, 9);cout << "Elements in array order are" << endl;cout << h << endl;return 0;
}

maxPriorityQueue.h

/*
Project name :			_25Priority_queue
Last modified Date:		2023年11月29日21点08分
Last Version:			V1.0
Descriptions:			优先级队列——大根堆抽象数据类型
*/#ifndef _25PRIORITY_QUEUE_MAXPRIORITYQUEUE_H
#define _25PRIORITY_QUEUE_MAXPRIORITYQUEUE_Htemplate<class T>
class maxPriorityQueue
{
public:virtual ~maxPriorityQueue() = default;[[nodiscard]] virtual bool empty() const = 0;// return true iff queue is empty[[nodiscard]] virtual int size() const = 0;// return number of elements in queuevirtual const T& top() = 0;// return reference to the max elementvirtual void pop() = 0;// remove the top elementvirtual void push(const T& theElement) = 0;// add theElement to the queue
};
#endif //_25PRIORITY_QUEUE_MAXPRIORITYQUEUE_H

_1myExceptions.h

/*
Project name :			allAlgorithmsTest
Last modified Date:		2022年8月13日17点38分
Last Version:			V1.0
Descriptions:			综合各种异常
*/
#pragma once
#ifndef _MYEXCEPTIONS_H_
#define _MYEXCEPTIONS_H_
#include <string>
#include<iostream>
#include <utility>using namespace std;// illegal parameter value
class illegalParameterValue : public std::exception
{
public:explicit illegalParameterValue(string theMessage = "Illegal parameter value"){message = std::move(theMessage);}void outputMessage() {cout << message << endl;}
private:string message;
};// illegal input data
class illegalInputData : public std::exception
{
public:explicit illegalInputData(string theMessage = "Illegal data input"){message = std::move(theMessage);}void outputMessage() {cout << message << endl;}
private:string message;
};// illegal index
class illegalIndex : public std::exception
{
public:explicit illegalIndex(string theMessage = "Illegal index"){message = std::move(theMessage);}void outputMessage() {cout << message << endl;}
private:string message;
};// matrix index out of bounds
class matrixIndexOutOfBounds : public std::exception
{
public:explicit matrixIndexOutOfBounds(string theMessage = "Matrix index out of bounds"){message = std::move(theMessage);}void outputMessage() {cout << message << endl;}
private:string message;
};// matrix size mismatch
class matrixSizeMismatch : public std::exception
{
public:explicit matrixSizeMismatch(string theMessage ="The size of the two matrics doesn't match"){message = std::move(theMessage);}void outputMessage() {cout << message << endl;}
private:string message;
};// stack is empty
class stackEmpty : public std::exception
{
public:explicit stackEmpty(string theMessage ="Invalid operation on empty stack"){message = std::move(theMessage);}void outputMessage() {cout << message << endl;}
private:string message;
};// queue is empty
class queueEmpty : public std::exception
{
public:explicit queueEmpty(string theMessage ="Invalid operation on empty queue"){message = std::move(theMessage);}void outputMessage() {cout << message << endl;}
private:string message;
};// hash table is full
class hashTableFull : public std::exception
{
public:explicit hashTableFull(string theMessage ="The hash table is full"){message = std::move(theMessage);}void outputMessage() {cout << message << endl;}
private:string message;
};// edge weight undefined
class undefinedEdgeWeight : public std::exception
{
public:explicit undefinedEdgeWeight(string theMessage ="No edge weights defined"){message = std::move(theMessage);}void outputMessage() {cout << message << endl;}
private:string message;
};// method undefined
class undefinedMethod : public std::exception
{
public:explicit undefinedMethod(string theMessage ="This method is undefined"){message = std::move(theMessage);}void outputMessage() {cout << message << endl;}
private:string message;
};
#endif

_2myFunctions.h

/*
Project name :			allAlgorithmsTest
Last modified Date:		2022年8月13日17点38分
Last Version:			V1.0
Descriptions:			综合各种非成员函数
*/
#pragma once
#ifndef _MYFUNCTIONS_H_
#define _MYFUNCTIONS_H_
#include<iostream>
#include "_1myExceptions.h"
#include<cmath>
#include <exception>
#include <memory>using std::min;
using std::endl;
using std::cout;
using std::bad_alloc;
/*交换两数据*/
template<class V>
void Swap(V& a, V& b)
{V temp = a;a = b;b = temp;
}
/*
作用：将数组的长度加倍
输入：指针a指向需要改变长度的数组，oldLength表示数组原来的长度，newLength表示需要改变的新长度
结果：将数组扩容/缩容 为newLength
*/
template<class T>
void changeLength(T*& a, int oldLength, int newLength)
{if (newLength < 0)throw illegalParameterValue("new length must be >= 0");T* temp = new T[newLength];int number = min(oldLength, newLength);copy(a, a + number, temp);delete[] a;a = temp;
}
/*遍历一维数组*/
template<class T>
void traverse1dArray(T* x, int length)
{for (int i = 0; i < length; i++)cout << x[i] << " ";cout << endl;
}
/*创建二维数组*/
template <class T>
bool make2dArray(T**& x, int numberOfRows, int numberOfColumns)
{try {//行指针x = new T * [numberOfRows];//为每一行分配内存for (int i = 0; i < numberOfRows; i++)x[i] = new int[numberOfColumns];return true;}catch (bad_alloc) { return false; }
}/*遍历二维数组*/
template<class T>
void traverse2dArray(T**& x, int numberOfRows, int numberOfColumns)
{for (int i = 0; i < numberOfRows; i++){for (int j = 0; j < numberOfColumns; j++){cout.width(4);cout << x[i][j] << "  ";}cout << endl;}
}
template<class T>
void changeLength1D(T*& a, int oldLength, int newLength)
{if (newLength < 0)throw illegalParameterValue("new length must be >= 0");T* temp = new T[newLength];              // new arrayint number = min(oldLength, newLength);  // number to copycopy(a, a + number, temp);a = temp;
}
#endif

运行结果

"C:\Users\15495\Documents\Jasmine\prj\_Algorithm\Data Structures, Algorithms and Applications in C++\_25Priority queue\cmake-build-debug\_25Priority_queue.exe"
Heap size is 3
Elements in array order are
20 10 5Heap size is 5
Elements in array order are
30 20 5 10 15The max element is 30
The max element is 20
The max element is 15
Heap size is 2
Elements in array order are
10 5Elements in array order are
9 8 7 4 5 6 3 2 1Process finished with exit code 0

这篇关于《数据结构、算法与应用C++语言描述》-优先级队列-大根堆的C++实现的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/434957。

相关文章

HTML5实现的移动端购物车自动结算功能示例代码

HTML5实现的移动端购物车自动结算功能示例代码

《HTML5实现的移动端购物车自动结算功能示例代码》本文介绍HTML5实现移动端购物车自动结算,通过WebStorage、事件监听、DOM操作等技术,确保实时更新与数据同步,优化性能及无障碍性,提升用... 目录1. 移动端购物车自动结算概述2. 数据存储与状态保存机制2.1 浏览器端的数据存储方式2.1.
阅读更多...
基于 HTML5 Canvas 实现图片旋转与下载功能(完整代码展示)

基于 HTML5 Canvas 实现图片旋转与下载功能(完整代码展示)

《基于HTML5Canvas实现图片旋转与下载功能(完整代码展示)》本文将深入剖析一段基于HTML5Canvas的代码，该代码实现了图片的旋转（90度和180度）以及旋转后图片的下载... 目录一、引言二、html 结构分析三、css 样式分析四、JavaScript 功能实现一、引言在 Web 开发中，
阅读更多...
SpringBoot中使用Flux实现流式返回的方法小结

SpringBoot中使用Flux实现流式返回的方法小结

《SpringBoot中使用Flux实现流式返回的方法小结》文章介绍流式返回（StreamingResponse）在SpringBoot中通过Flux实现,优势包括提升用户体验、降低内存消耗、支持长连... 目录背景流式返回的核心概念与优势1. 提升用户体验2. 降低内存消耗3. 支持长连接与实时通信在Sp
阅读更多...
Conda虚拟环境的复制和迁移的四种方法实现

Conda虚拟环境的复制和迁移的四种方法实现

《Conda虚拟环境的复制和迁移的四种方法实现》本文主要介绍了Conda虚拟环境的复制和迁移的四种方法实现,包括requirements.txt,environment.yml,conda-pack,... 目录在本机复制Conda虚拟环境相同操作系统之间复制环境方法一：requirements.txt方法
阅读更多...
Spring Boot 实现 IP 限流的原理、实践与利弊解析

Spring Boot 实现 IP 限流的原理、实践与利弊解析

《SpringBoot实现IP限流的原理、实践与利弊解析》在SpringBoot中实现IP限流是一种简单而有效的方式来保障系统的稳定性和可用性,本文给大家介绍SpringBoot实现IP限... 目录一、引言二、IP 限流原理2.1 令牌桶算法2.2 漏桶算法三、使用场景3.1 防止恶意攻击3.2 控制资源
阅读更多...
springboot下载接口限速功能实现

springboot下载接口限速功能实现

《springboot下载接口限速功能实现》通过Redis统计并发数动态调整每个用户带宽,核心逻辑为每秒读取并发送限定数据量,防止单用户占用过多资源,确保整体下载均衡且高效,本文给大家介绍spring... 目录 一、整体目标 二、涉及的主要类/方法✅ 三、核心流程图解（简化） 四、关键代码详解1️⃣ 设置
阅读更多...
Nginx 配置跨域的实现及常见问题解决

Nginx 配置跨域的实现及常见问题解决

《Nginx配置跨域的实现及常见问题解决》本文主要介绍了Nginx配置跨域的实现及常见问题解决,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来... 目录1. 跨域1.1 同源策略1.2 跨域资源共享（CORS）2. Nginx 配置跨域的场景2.1
阅读更多...
Python中提取文件名扩展名的多种方法实现

Python中提取文件名扩展名的多种方法实现

《Python中提取文件名扩展名的多种方法实现》在Python编程中,经常会遇到需要从文件名中提取扩展名的场景,Python提供了多种方法来实现这一功能,不同方法适用于不同的场景和需求,包括os.pa... 目录技术背景实现步骤方法一：使用os.path.splitext方法二：使用pathlib模块方法三
阅读更多...
CSS实现元素撑满剩余空间的五种方法

CSS实现元素撑满剩余空间的五种方法

《CSS实现元素撑满剩余空间的五种方法》在日常开发中，我们经常需要让某个元素占据容器的剩余空间，本文将介绍5种不同的方法来实现这个需求，并分析各种方法的优缺点，感兴趣的朋友一起看看吧... css实现元素撑满剩余空间的5种方法 在日常开发中，我们经常需要让某个元素占据容器的剩余空间。这是一个常见的布局需求
阅读更多...
CSS中的Static、Relative、Absolute、Fixed、Sticky的应用与详细对比

CSS中的Static、Relative、Absolute、Fixed、Sticky的应用与详细对比

《CSS中的Static、Relative、Absolute、Fixed、Sticky的应用与详细对比》CSS中的position属性用于控制元素的定位方式，不同的定位方式会影响元素在页面中的布... css 中的 position 属性用于控制元素的定位方式，不同的定位方式会影响元素在页面中的布局和层叠关
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2