手写priority queue

已于 2023-09-03 23:57:11 修改
阅读量221 收藏
点赞数
分类专栏： 练习 文章标签： 数据结构 c++
于 2022-04-20 19:51:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45419976/article/details/124304468
版权

文章目录

要求：

1、完成priority queue的基本功能
2、在至多logn的时间复杂度合并两个priority queue

基本功能（顺序存储）

#ifndef SJTU_PRIORITY_QUEUE_HPP
#define SJTU_PRIORITY_QUEUE_HPP

#include <cstddef>
#include <functional>
#include "exceptions.hpp"
#include<iostream>
namespace sjtu {
	
//  a container like std::priority_queue which is a heap internal.
//用cmp！！！Compare函数！ 
template<typename T, class Compare = std::less<T>>
class priority_queue {
	private:
		T *data;
		int siz,capacity;
		void DoubleSpace(){
			if(capacity==0) {
				capacity = 5 ;
				data = (T *) malloc(sizeof(T)*capacity);
				return ;
			}
			capacity *= 2;
			T *data2 = (T *)malloc(sizeof(T)*capacity);
			for(int i=1;i<=siz;i++){//注意这里siz < capacity/2! 
				new(data2+i)T(data[i]);
			}
			for(int i=1;i<=siz;i++){
				data[i].~T();
			}
			free(data);
			data = data2;
		}
	public:
		// TODO constructors
		priority_queue(int maxsize = 5) {
			siz = 0;
//			capacity = 0;//不能不初始化！！！！capacity=0要写！！ 
//			DoubleSpace();//或者采用未注释的写法 
			data = (T *)malloc (sizeof(T)*maxsize); 
			capacity = maxsize;
		}
		priority_queue(const priority_queue &other) {//copy constructor
			data = (T *) malloc(sizeof(T)*other.capacity);
			for(int i=1;i<=other.siz ;i++){
				new(data+i)T(other.data[i]);
			}
			capacity = other.capacity ;
			siz = other.siz ;
		}
		
		//TODO deconstructor
		~priority_queue() {
			for(int i=1;i<=siz;i++){
				data[i].~T();
			}
			free(data);
			siz = 0;
			capacity = 0;
			data = NULL;
		}
		
		//TODO Assignment operator
		priority_queue &operator=(const priority_queue &other) {
			if(this == &other) return *this;
			for(int i=1;i<=siz;i++){
				data[i].~T();
			}
			if(other.siz > capacity){
				free(data);
				data = (T *)malloc(sizeof(T)*other.capacity);
				capacity = other.capacity;
			}
			for(int i=1;i<=other.siz;i++){
				new(data+i)T(other.data[i]);
			}
			siz = other.siz;
			return *this;
		}
		
		/* get the top of the queue.
		 * @return a reference of the top element.
		 * throw container_is_empty if empty() returns true;
		 */
		const T & top() const {
			if(empty()) throw container_is_empty();
			return data[1];
		}
		
		// push new element to the priority queue.
		void push(const T &e) {//大顶堆
			if(siz>=capacity-1) 
				DoubleSpace();
			siz ++;
			int hole = siz;
			new(data+hole)T(e);//是这里，要写一个构造的而不是重载等于，因为本身没有T类型的变量 
			while(hole>1 && Compare()(data[hole>>1],e)){
				data[hole] = data[hole>>1];//不需要重复析构，因为在T类型重载等号已经写了 
				hole = hole>>1;
			} 
			data[hole] = e;
		}
		/* delete the top element.
		 * throw container_is_empty if empty() returns true;
		 */
		void pop() {
			if(siz==0) throw container_is_empty(); 
			int hole = 1;
			while(hole*2 < siz){//至少有一个儿子在下面呀！ 
				int child = hole<<1;
				if(child+1<siz && Compare()(data[child],data[child+1])){
					child++;
				}
				if(Compare()(data[child],data[siz])) break;
				data[hole] = data[child];
				hole = child;
			}
			data[hole] = data[siz];
			data[siz].~T();
			siz--;
		}
		// return the number of the elements.
		size_t size() const {
			return siz;
		}
		/* check if the container has at least an element.
		 * @return true if it is empty, false if it has at least an element.
		 */
		bool empty() const {
			if(siz) return false;
			return true;
		}
	};
}

#endif
  • 用Compare函数来确定是大顶堆还是小顶堆！这里是大顶堆
  • 没法实现logn的合并
  • 在doublespace的时候特别注意siz和capacity的关系，因为进入doublespace的时候siz = capacity-1（申请5个空间，0不能用，只能放四个值），不管是析构还是复制都要小心，判别是否进入doublespace时也要小心
  • 顺序存储特别注意构造和析构，什么时候写构造什么时候写赋值（赋值是可能析构掉原来的，看具体的实现），析构是你做还是赋值的时候做，析构时要不要一起析构掉空间……都很重要

连接存储（左堆）

 #ifndef SJTU_PRIORITY_QUEUE_HPP
#define SJTU_PRIORITY_QUEUE_HPP

#include <cstddef>
#include <functional>
#include "exceptions.hpp"

namespace sjtu {
/**
 * a container like std::priority_queue which is a heap internal.
 */
template<typename T, class Compare = std::less<T>>
class priority_queue {
	private:
		struct Node{
			Node *left,*right;
			T *data;
			int npl;
			Node(const T &x,Node *l = NULL,Node *r = NULL){
				data = new T(x);
				left = l;
				right = r;
				npl = -1;
			}
			~Node(){
				if(data) delete data;//易忘if 
				left = NULL;
				right = NULL;
			}
		}; 
		Node *head;
		int siz; 
		Node *copy(Node *q){
			Node *p = new Node(*(q->data));
			if(q->left){
				p->left = copy(q->left);
			}
			if(q->right){
				p->right = copy(q->right);
			}
			return p;
		}
		void clear(Node *p){//有可能clear的时候本身就是p==NULL!! 
			if(p==NULL) return ;
			if(p->left) 
				clear(p->left);
			if(p->right)
				clear(p->right);
			delete p;
			return ;
		}
		void getnpl(Node *u){
			if(u==NULL) {//npl=-1
				return ;
			}
			if(u->left==NULL || u->right==NULL) {
				u->npl = 0;
				return ;
			}
			int x,y;
			if(u->left!=NULL && u->left->npl == -1) 
				getnpl(u->left);
			if(u->right!=NULL && u->right->npl == -1) 
				getnpl(u->right);
			if(u->left->npl < u->right->npl)
				u->npl = u->left->npl+1;
			else u->npl = u->right->npl+1;
			return;
		}
		void check(Node *u){
			getnpl(u);
			if(u->left==NULL || u->left->npl < u->right->npl){
				Node *tmp = u->left;
				u->left = u->right;
				u->right = tmp;
			}
			return ;
		}
		Node *merge(Node *u,Node *v,Node *fau,Node *fav){//考虑一下合并后u原先的father还指着它！ 
			if(u==NULL) return v;
			if(v==NULL) return u;
			Node *fa = fau;
			//85-86行先声明Compare类型变量再用重载的括号，和直接写if(Compare()(*(v->data),*(u->data)))效果一样 
			Compare cmp;
			if(cmp(*(v->data),*(u->data))){
				Node *tmp = u;
				u = v;
				v = tmp;
				fa = fav;
			}//u是小的 ,用u和v的右子树合并
			if(v->right == NULL){
				v->right = u;
				check(v);
				return v;
			} 
			v->right = merge(u,v->right,fau,v);
			check(v);
			if(fa==NULL) return v;
			if(fa->left == u) fa->left = NULL;
			if(fa->right ==v) fa->right = NULL;
			return v;
		}
	public:
		priority_queue() {
			siz = 0;
			head = NULL;
		}
		priority_queue(const priority_queue &other) {
			siz = other.siz ;
			head = copy(other.head);
		}
		~priority_queue() {
			clear(head);
			head = NULL;
			siz = 0; 
		}
		priority_queue &operator=(const priority_queue &other) {
			if(this == &other) return *this;//易忘 
			clear(head);
			siz = other.siz ;
			head = copy(other.head);
			return *this; //易忘 
		}
		const T & top() const {
			if(empty()) throw container_is_empty();
			return *(head->data);
		}
		void push(const T &e) {
			Node *tmp = new Node(e);
			head = merge(head,tmp,NULL,NULL);//特判放在merge里面做了 
			siz ++;
		}
		void pop() {
			if(empty()) throw container_is_empty();
			Node *tmp = head;
			head = merge(head->left,head->right,NULL,NULL);
			delete tmp;
			siz--;
		}
		size_t size() const {
			return siz;
		}
		bool empty() const {
			return siz==0;
		}
		/**
		 * merge two priority_queues with at least O(logn) complexity.
		 * clear the other priority_queue.
		 */
		void merge(priority_queue &other) {//传的参数是堆，里面的函数传进去结点 
			 head = merge(head,other.head,NULL,NULL); 
			 siz += other.siz;
			 other.head = NULL;
			 other.siz = 0;
			 return ;
		}
	};
}

#endif
  • 写好了merge和其他private函数以后public写起来很舒服哎！
  • 关于Compare的用法：Compare在code实现里面是一个结构体cmp，使用的时候可以先声明一个Compare实例，然后再用重载的调用运算符即括号，来使用cmp操作；也可以写一个语句即if(Compare()(*(v->data),*(u->data)))，第一个空括号表示构造一个Compare类型的实例，第二个括号才表示使用这个重载的调用运算符。
  • 注意merge里面的特判……如果传进去俩NULL咋整？
  • check也记得特判，很有可能u->left就是NULL，你用->left->data就会377
  • npl要用一定程度的记忆化，否则每次都搜会超时，虽然我用的记忆化方法也不是很快，但是好歹没有TLE
  • 其他特别特别容易写忘记的点：
    delete之前先判是不是NULL，不是再delete
    重载等号的时候，开头的判if(this==&other)，尾巴的return *this;
  • 以后做题前能不能先看看题，要用顺序还是链接，就不至于像这次一样两个都写……
矿矿不想吃饭
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
手写一个优先队列（PriorityQueue）
皮皮狗
08-19 1255
实现了优先队列的添加与删除方法 优先队列利用最小堆来实现 主要方法：删除堆顶元素、添加元素后最小堆的维护 代码实现 package basicKnowledge.集合框架.priorQueue; import basicKnowledge.集合框架.queue.MyListQueue; import com.sun.xml.internal.bind.v2.schemagen.x...
AcWing 堆排序 题解（手写堆/优先队列priority_queue 模板）
qiaodxs的博客
08-12 179
//堆（优先队列） //堆是以完全二叉树的形式存于一维数组（第一个节点为1） #include<iostream> #include<algorithm> using namespace std; const int N = 1e5 + 10; int h[N], Size; int n, m; void down(int u){//输入要操作的节点 int t = u;//将该节点标记 if(u * 2 <= Size && h[u*2] &l
手写堆&&priority_queue优先队列
陈进士学习的博客
05-02 888
priority_queue 也没有迭代器，因此访问元素的唯一方式是遍历容器，通过不断移除访问过的元素，去访问下一个元素。3. 如果数据类型比较复杂，建议优先队列，如Dijkstra堆优化等。2. 优先队列相对数组模拟速度要慢一些。，所以如果有以上需求需要手写堆。
手写 PriorityQueue的实现 java
你的C有点长
11-03 172
对于一个堆结构来说，我们应用的很广。常见的就有我们学的八大排序之一的而堆排序。其实堆就是一个完全二叉树结构（逻辑结构），但我们真实实现的底层是基于数组。 首先，我们温故一下堆排序，然后通过这一理念对应想想PriorityQueue的一些方法于是我们就可以实现一些功能，这边我只实现一部分比较常用的功能。 先堆排序： 代码： //用来交换数值 public static void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = ar
最小的K个数（手写大顶堆和用优先级队列比较）
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
12-30 1591
题目描述 输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。 题目链接：https://www.nowcoder.com/practice/6a296eb82cf844ca8539b57c23e6e9bf?tpId=13&amp;tqId=11182&amp;tPage=2&amp;rp=2&amp;ru=/ta/codin...
Interview-priority queue
zerods-seu的博客
01-11 926
Dynamic median.Randomized priority queue.Taxicab numbers.
余纪平—pb_ds库在OI中的应用.
07-20
在性能测试中，gnu_pbds::priority_queue 的性能优于 std::priority_queue 和手写的线段树。因此，在实际应用中，gnu_pbds::priority_queue 是一个不错的选择。 gnu_pbds::priority_queue 是一个功能强大且高效的...
标准模板库STL
04-02
- **优先队列（priority_queue）**：堆实现，总是保持最大元素在顶部。 - **关联容器（multiset和multimap）**：与set和map类似，但允许重复元素。 **2. 迭代器** 迭代器是STL中访问容器内元素的关键工具，它扮演着...
STL.rar_STL_visual c
09-14
5. 队列和堆（queue和priority_queue）：队列遵循FIFO（先进先出）原则，而堆是一种特殊的树形数据结构，可以快速找到最大或最小元素。 6. 算法（Algorithms）：STL提供了一套丰富的算法库，如find、sort、...
C++_STL编程轻松入门.pdf
09-30
- **适配器（Adapters）**：改变容器或迭代器行为的工具，例如stack、queue、priority_queue等。 4. **STL的优势** - **复用性**：STL提供了一套标准的接口，程序员可以重用这些接口来实现不同的数据结构和算法，...
stl源码剖析.zip
06-09
5. **适配器**：适配器类如priority_queue（优先队列）、stack（栈）和queue（队列）是基于现有容器和算法的封装，简化了常见数据结构的使用。 6. **内存管理**：STL的内存管理由allocator（分配器）负责，它隐藏了...
priority_queue的使用 详细总结
carol_in_love的博客
05-08 1792
参考博文：https://blog.csdn.net/weixin_36888577/article/details/79937886 最近做到一些使用堆排序的题，因此总结一下priority_queue 优先队列也是队列，因此头文件为，与queue的不同在于可以定义数据的优先级，在插入数据时会自动排序。 基本操作 top 访问队头元素 push 插入元素到队尾并排序 pop 弹出队头元素 em...
priority_queue & 结构体||类 & 自定义比较函数cmp
hongxdong的专栏
05-05 6195
   template                     class Sequence=vector ,                     class Compare=less >  #include #include #include using namespace std;struct node {     int no;     int year;
priority_queue/LeetCode 23题
吃鱼的博客
04-09 762
priority_queue priority_queue的本质是一个堆，堆的概念就是一个存储数据的数组。 堆可以看成是一个完全二叉树。 其中，根节点最大的堆是大根堆，根节点最小的堆是小根堆。堆中某个节点的值总是不大于或者不小于其父节点的值。 算法思想：交换。例如在一个已经是大根堆的堆中插入一个新的值，首先把其插入到堆一个子节点上，称为新的一个节点，如果这个值已经比其父节点要小了，那么就成了。如...
priority_queue的优先级变化（结构体的写法）
weixin_33875839的博客
12-13 700
priority_queue的优先级变化（结构体的写法） 在头文件中加上#include <queue> 即可使用stl中的库函数priority_queue，优先队列默认的是从大到小的优先级，但是我们在实际使用的时候，往往需要改变优先级（比如从小到大的排列），这时候就需要改变优先级。 //定义结构，使用运算符重载,自定义优先级1 struct cmp1{ bool ...
c++学习之优先队列(priority_queue)
qingtianweichong的专栏
08-17 1472
优先队列的思想是比较简单的，就是在队列的基础上按照某一特定元素进出队列，计算机中作业的优先调度，就是按照作业的权值优先，先出队列。在STL容器中，优先队列的实现是使用的heap，也就是堆，用一个二叉堆维护一个优先队列，具体的堆的使用方法不做介绍，主要是了解priority_queue的基本使用方法及一点需要注意的地方。基本使用方法和其他的容器一样，需要将模版具象化，也就是指明类型，然后通过接口调用
优先队列 （干掉手写堆 呜呜呜~~）
qq_42146446的博客
07-19 597
优先队列 优先队列中的元素会按某种优先级依次出队列，即可实现按此优先级排序，时间复杂度和堆排序差不多   优先队列的头文件   #include&lt;queue&gt;   优先队列的定义式 1. priority_queue&lt;int&gt; q; 默认优先级从到大到小        priority_queue&lt;int,vector&lt;int&gt;,greate...
4.1 手写Java PriorityQueue 核心源码 - 原理篇
weixin_30433075的博客
12-07 80
4.1 手写Java PriorityQueue 核心源码 - 原理篇 本章先讲解优先级队列和二叉堆的结构。下一篇代码实现 从一个需求开始 假设有这样一个需求：在一个子线程中，不停的从一个队列中取出一个任务，执行这个任务,直到这个任务处理完毕，再取出下一个任务，再执...
【C++】STL中 sort、priority_queue 自定义 cmp 方法汇总（code c++）
idiot5lie的博客
04-01 4273
目录&索引1 sort 函数中的 cmp1.1 重载小于运算符1.2 自定义 cmp 函数1.3 自定义仿函数1.4 自定义 lambda 表达式1.5 输出结果（逆序）2 priority_queue 中的 cmp2.1 重载小于运算符2.2 自定义仿函数2.3 自定义 lambda 表达式2.4 输出结果（小顶堆）3 结论 1 sort 函数中的 cmp 1.1 重载小于运算符 sort 重载小于运算符，重载示例如下： #include <iostream> #include &l
priority queue
最新发布
10-12
优先队列（Priority Queue）是一种特殊的队列，它的每个元素都有一个权重值，高权重的元素优先被排在队列的前面，可以用来实现一些贪心算法和Dijkstra算法等。 在C++中，可以使用STL中的priority_queue来实现优先队列。priority_queue默认是大根堆，也可以通过自定义比较函数来实现小根堆。 以下是一个使用priority_queue实现小根堆的例子： ```c++ #include <iostream> #include <queue> using namespace std; int main() { priority_queue<int, vector<int>, greater<int>> pq; // 小根堆 pq.push(3); pq.push(1); pq.push(4); pq.push(1); while (!pq.empty()) { cout << pq.top() << " "; pq.pop(); } return 0; } ``` 输出结果为：1 1 3 4
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值