C++queue和priority_queue的实现

原创 于 2024-10-13 23:00:12 发布 · 918 阅读 · 15 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #数据结构

queue和priority_queue的实现

1、源代码

queue.h

#pragma once
#include<deque>
#include<vector>
#include<algorithm>
#include<assert.h>

namespace sdf
{
	template <class T, class container = std::deque<T>>
	class queue
	{
	public:
		void pop()
		{
			assert(!empty());
			_con.pop_back();
		}
		void push(const T& val)
		{
			_con.push_back(val);
		}

		T& front()
		{
			assert(!empty());
			return _con.front();
		}
		const T& front()const
		{
			assert(!empty());
			return _con.front();
		}

		T& back()
		{
			assert(!empty());
			return _con.back();
		}
		const T& back()const
		{
			assert(!empty());
			return _con.front();
		}
		bool empty()const//
		{
			return _con.empty();
		}
		size_t size()const//
		{
			return _con.size();
		}

	private:
		container _con;
	};

	template <class T>
	struct Greater
	{
		bool operator() (const T& val1, const T& val2){
			return val1 > val2;
		}
	};
	template <class T>
	struct Less
	{
		bool operator() (const T& val1, const T& val2) {
			return val1 < val2;
		}
	};
	template<class T, class Container = std::vector<T>, class Compare = Less<T>>//有了仿函数能够自己控制是大堆还是小堆，
	class priority_queue                                                        //函数指针同样能达到效果,但C++中的仿函数写起来更加简单
	{ 
	public:
		void UpJust(size_t child)
		{
			Compare compar;
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				/*Less<int> funcLess;
				funcLess(1, 2);//funcLess.operator() (1,2)  仿函数：对象能够像函数一样进行调用，其实就是类中重载了()函数
				v0[1];//v0.operator[](1)
				Less<int>() (1, 2);//Less<int>().operator() (1,2)*/

				if (compar(_con[parent], _con[child])) {
					std::swap(_con[parent], _con[child]);//vector中有swap()
				}else{
					break;
				}
				child = parent;
				parent = (child - 1) / 2;
			}
		}
		void push(const T& val)
		{
			_con.push_back(val);
			UpJust(size()-1);
		}
		size_t size()
		{
			return _con.size();
		}
		void DownJust()
		{
			Compare compar;
			int parent = 0;
			int child = parent*2 + 1;
			if ((parent * 2 + 2) <= (size() - 1) && compar(_con[child], _con[child+1])) { //(parent*2+2)就是child+1
				child = parent * 2 + 2;                                                   //为了保险加一个_con[child] > _con[chold+1]的比较
			}

			while (child <= (size()-1))
			{
				if ( compar(_con[parent], _con[child]) ){
					std::swap(_con[parent], _con[child]);
				}else{
					break;
				}
				parent = child;
				child = parent * 2 + 1;
				if ((parent * 2 + 2) <= (size() - 1) && compar(_con[child], _con[child + 1])) {
					child = parent * 2 + 2;
				}
			}
		}
		void pop()
		{
			std::swap(_con[0], _con[size()-1]);
			_con.pop_back();
			if (size() > 0)
				DownJust();
		}
		bool empty()const
		{
			return _con.empty();
		}
		const T& top()const
		{
			return _con[0];
		}
		T& top()
		{
			return _con[0];
		}

	private:
		Container _con;
	};
};

Date.h

#pragma once
#include<iostream>
using namespace std;

class Date
{
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);
public:
	bool CheckDate(int year, int month, int day);
	Date(int year = 2024, int month = 9, int day = 8);
	Date(const Date& d);
	Date& operator=(const Date& d);
	bool operator>(const Date& d)const;
	bool operator==(const Date& d)const;
	bool operator>=(const Date& d)const;
	bool operator<(const Date& d)const;
	bool operator<=(const Date& d)const;
	bool operator!=(const Date& d)const;


	int GetMonthDay(int year, int month)
	{
		static int YearMonthDay[13] = { -1,31,28,31,30,31,30,31,31,30,31,30,31 };
		if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))
			return 29;

		return YearMonthDay[month];
	}
	Date& operator+=(int day);
	Date operator+(int day)const;
	Date& operator-=(int day);
	Date operator-(int day)const;
	Date& operator++();
	Date operator++(int);
	Date& operator--();
	Date operator--(int);
	int operator-(const Date& d)const;
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& out, const Date& d);
istream& operator>>(istream& in, Date& d);

Date.cpp

#include"Date.h"

bool Date::CheckDate(int year, int month, int day)
{
	if (month <= 0 || month >= 13 || day <= 0 || day > GetMonthDay(year, month)) {
		cout << "请输入合法日期" << endl;
		return false;
	}
	return true;
}
ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << " " << d._month << " " << d._day;
	return out;
}
istream& operator>>(istream& in, Date& d)
{
	int year, month, day;
	do {
		in >> year >> month >> day;
	} while (!d.CheckDate(year, month, day));

	d._year = year;
	d._month = month;
	d._day = day;
	return in;
}
Date::Date(int year, int month, int day)
{
	_year = year;
	_month = month;
	_day = day;
}
Date::Date(const Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}
Date& Date::operator=(const Date& d)
{
	if (this!=&d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	return *this;
}
bool Date::operator>(const Date& d)const
{
	if (_year > d._year)
	{
		return true;
	}
	else if (_year == d._year)
	{
		if (_month > d._month)
		{
			return true;
		}
		else if (_month == d._month && _day > d._day)
		{
			return true;
		}
	}
	return false;
}
bool Date::operator==(const Date& d)const
{
	if (_year == d._year && _month == d._month && _day == d._day)
	{
		return true;
	}
	return false;
}
bool Date::operator>=(const Date& d)const
{
	return *this > d || *this == d;
}
bool Date::operator<(const Date& d)const
{
	return !(*this >= d);
}
bool Date::operator<=(const Date& d)const
{
	return *this < d || *this == d;
}
bool Date::operator!=(const Date& d)const
{
	return !(*this == d);
}


Date& Date::operator+=(int day)
{
	_day += day;
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		_month += 1;
		if (_month == 13)
			_year += 1;
	}
	return *this;
}
Date Date::operator+(int day)const
{
	Date tmp = *this;
	return tmp += day;
}
Date& Date::operator-=(int day)
{
	_day -= day;
	while (_day <= 0)
	{
		--_month;
		if (_month == 0)
		{
			_year -= 1;
			_month = 12;
		}
		_day += GetMonthDay(_year, _month);
	}
	return *this;
}
Date Date::operator-(int day)const
{
	Date tmp = *this;
	return tmp -= day;
}
Date& Date::operator++()
{
	return *this += 1;
}
Date Date::operator++(int)
{
	Date d = *this;
	*this += 1;
	return d;
}
Date& Date::operator--()
{
	return *this -= 1;
}
Date Date::operator--(int)
{
	Date d = *this;
	*this -= 1;
	return d;
}
int Date::operator-(const Date& d)const
{
	Date MaxDay = *this;
	Date MinDay = d;
	int flage = 1;
	if (*this < d)
	{
		MinDay = *this;
		MaxDay = d;
		flage = -1;
	}
	int difference = 0;
	while (MinDay != MaxDay)
	{
		++MinDay;
		++difference;
	}
	return flage * difference;
}

test.cpp

#include"queue.h"
#include"Date.h"
#include<iostream>

int main()
{
	sdf::queue<int> qe;
	qe.push(13);
	qe.push(12);
	std::cout << qe.front() << std::endl;
	std::cout << qe.back() << std::endl;
	qe.pop();
	std::cout << qe.size() << std::endl;

	sdf::priority_queue<int> qe2;
	qe2.push(3);
	qe2.push(8);
	qe2.push(2);
	while (!qe2.empty())
	{
		std::cout << qe2.top() << " ";
		qe2.pop();
	}
	std::cout << std::endl;

	sdf::priority_queue<Date> qe3;
	Date d0(2024, 4, 6);
	qe3.push(d0);
	qe3.push(Date(2024, 4, 7));
	qe3.push({ 2024,4,8 });
	while (!qe3.empty())
	{
		std::cout << qe3.top() << " ";
		qe3.pop();
	}
	std::cout << std::endl;

	return 0;
}

运行结果：

2、分析

2.1适配器模式

适配器模式是一种设计模式，该种模式是将一个类的接口转换成客户希望的另外一个接口。在STL中stack和queue并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为栈和队列只是对其他容器的接口进行了包装。

2.2双端队列(deque)

双端队列支持迭代器、任意位置随机访问、任意位置的插入和删除

底层原理图（deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组）

1、vector容器的优点和缺陷

  • 支持任意位置的随机访问
  • 头部和中间位置的插入、删除效率低
  • 扩容有消耗

2、list容器的优点和缺陷

  • 头部和中间位置的插入、删除效率高
  • 不支持任意位置的随机访问

3、deque容器的优点和缺陷

  • 与vector比较，deque的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不 需要搬移大量的元素，因此其效率是必比vector高的。
  • 与list比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。
  • 不适合遍历（因为在遍历时，deque的迭代器要频繁的去检测其是否移动到 某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作 为stack和queue的底层数据结构）
  • 下标[]访问不够极致

4、为什么选择deque作为stack和queue的底层默认容器

  • stack和queue不需要遍历，只需要在固定的一端或者两端进行操作。
  • 在stack中元素增长时，deque比vector的效率高(扩容时不需要搬移大量数据)；queue中的元素增长
    时，deque不仅效率高，而且内存使用率高。
  • 结合了deque的优点，而且完美的避开了其缺陷。

2.3priority_queue（底层数据结构是堆）

插入（尾插，然后与父节点比较向上调整）

		void UpJust(size_t child)
		{
			Compare compar;
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				if (compar(_con[parent], _con[child])) {
					std::swap(_con[parent], _con[child]);//vector中有swap()
				}else{
					break;
				}
				child = parent;
				parent = (child - 1) / 2;
			}
		}
		void push(const T& val)
		{
			_con.push_back(val);
			UpJust(size()-1);
		}

删除（如果头删之后，整体向前移动，时间复杂度为O(N)。如果头部的数据与尾部的数据交换，尾删，然后头部数据在向下调整，这样时间复杂度为O(logN)）

void DownJust()
{
	Compare compar;
	int parent = 0;
	int child = parent*2 + 1;
	if ((parent * 2 + 2) <= (size() - 1) && compar(_con[child], _con[child+1])) { 
		child = parent * 2 + 2;                                                   
	}
	while (child <= (size()-1))
	{
		if ( compar(_con[parent], _con[child]) ){
			std::swap(_con[parent], _con[child]);
		}else{
			break;
		}
		parent = child;
		child = parent * 2 + 1;
		if ((parent * 2 + 2) <= (size() - 1) && compar(_con[child], _con[child + 1])) {
			child = parent * 2 + 2;
		}
	}
}
void pop()
{
	std::swap(_con[0], _con[size()-1]);
	_con.pop_back();
	if (size() > 0)
		DownJust();
}

2.4仿函数

std::sort(vr0.begin(), vr0.end(), PriceGreater())按照价格从高到低来排

std::sort(vr0.begin(), vr0.end(), PriceGreater())按照评价从低到高来排

C/C++ 队列queue算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-27 2647
队列（Queue）是一种常用的数据结构，它采用先进先出（First-In-First-Out, FIFO）的原则来管理数据。队列算法的基本操作包括入队（enqueue）、出队（dequeue）和判空（empty）。队列算法的基本操作包括入队（enqueue）、出队（dequeue）和判空（empty）。队列算法的基本操作包括入队（enqueue）、出队（dequeue）和判空（empty）。队列算法的基本操作包括入队（enqueue）、出队（dequeue）和判空（empty）。
C++实现队列queue(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-11 1141
实现队列queue实现队列queue算法的完整源码（定义，实现） 实现队列queue算法的完整源码（定义，实现） #ifndef DATA_STRUCTURES_QUEUE_H_ #define DATA_STRUCTURES_QUEUE_H_ #include <cassert> #include <iostream> /** Definition of the node */ template <class Kind> struct node { Kind
queue源码C++
10-17
queue源码，是一个很不错的C++源码，有兴趣的伙伴们抽时间可以看一下把。
队列（c++源码）
m晴朗的博客
07-04 804
queue.h #ifndef QUEUE_H_ #define QUEUE_H_ #include<iostream> template<class T> struct Node { T data; Node<T>* next; }; template<class T> class Queue { private: Node<T>* front; Node<T>* rear; public: Queue(); ~Queue
C++(STL):23 ---序列式容器queue源码剖析
网易搬砖头
12-17 596
一、queue概述queue是一种先进先出（First In First Out，FIFO）的数据结构。它有两个出口，形式如下图所示特点：queue允许新增元素、移除元素、从最底端加入元...
C++ queue&priority_queue
Han同学
01-06 1332
C++ 队列&优先级队列
C++模拟实现priority_queue(优先级队列)
最新发布
zjxuec的博客
08-18 1109
从上图我们可以看出， priority_queue也是一个容器适配器，我们使用vector容器来模拟实现priority_queue。 我们主要实现的接口便是push、pop、top、size、empty。在这里为什么要使用vector来模拟实现priority_queue呢，因为实现priority_queue就和我们实现堆一样，我们要实现对找到父亲和孩子节点，就必须要使用数组进行查找，所以实现priority_queue的底层是vector。对于堆的知识可以移步:二叉树详解_二叉树原理详解-CSDN
C++ priority_queue简单源码剖析：priority_queue模拟实现
Lvision2的博客
06-03 1175
被叫做优先队列优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)，其数据结构类似于大堆。优先队列被实现为容器适配器容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。
C++:queue和priority_queue
qq_43441284的博客
08-12 407
优先队列（priority_queue）是一种特殊的队列，其中每个元素都被赋予了一个优先级。元素的出队顺序是根据它们的优先级来决定的，而不是它们被插入到队列中的顺序。在默认情况下，最高优先级的元素会被首先移除（即，对于最大堆实现的优先队列，最大的元素会被首先移除）。
C++ priority_queue的使用与简单实现
m0_68142120的博客
08-17 903
1. 是一种容器适配器2.优先使用vector作为其底层存储数据的容器。3. 使用了堆算法将vector中元素构造成堆的结构，所以priority_queue类似于堆，用的到堆的地方都可以考虑使用priority_queue。4.默认情况下priority_queue建立的是大堆。5.使用时只需包含#include<queue>即可其底层容器需要支持随机访问迭代器(Random-access iterators)以便自身在内部始终保持堆结构。这些由容器适配器自动完成，通过自动调用算法函数。
queue的C++实现
06-28
队列的实现C++···························
C++实现队列源代码
09-15
数据结构实验基础——使用C++实现队列源代码
C++代码Queue队列
01-13
C++数据结构与算法分析中的队列的实现代码，代码可以运行的
队列类Queue的C++实现
04-06
队列类Queue的C++实现
C++使用二个栈实现queue(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-11 319
C++使用二个栈实现queue使用二个栈实现queue算法的完整源码（定义，实现，main函数测试） 使用二个栈实现queue算法的完整源码（定义，实现，main函数测试） #include <cassert> #include <iostream> #include <stack> namespace { /** * @brief Queue data structure. Stores elements in FIFO * (first-in-first-out
聊聊C++标准库中优先队列priority_queue的源码
FlushHip
01-02 2127
C++标准库提供了优先队列priority_queue，顾名思义，就是可以按照优先级出队的队列，而且时间复杂度为O(logn)O(logn)O(logn)，算法中有很多优化项就是用优先队列来优化的。 C++11的标准库是怎么构造出优先队列的呢？优先队列是用堆来构造的。所以，优先队列其实并不能叫队列，它的完整定义应该是这样的：优先队列是用堆来构造，包装成队列的适配器。 其实想一想，堆确实适合构造优先...
【C++】STL之stack/queue类源码剖析
phoenixFlyzzz的博客
04-28 2045
通过双端队列deque适配器实现stack、queue
C++使用链表实现queue之一(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-11 404
使用使用链表实现queue使用使用链表实现queue算法的完整源码（定义，实现，main函数测试） 使用使用链表实现queue算法的完整源码（定义，实现，main函数测试） #include <iostream> struct linkedlist { int data; linkedlist *next; }; class stack_linkedList { public: linkedlist *front; linkedlist *rear;
C++ 队列（queue）实现（附源码）
input_me的博客
06-27 1624
周知众所，队列（queue）是计算机技术中常见的数据结构，先入先出，先进去的就先出来。为了更好地了解队列的结构和原理，用单链表来简单实现队列。
c++queue和priority_queue
10-03
queue 和 priority_queue 都是容器适配器，用于实现队列的数据结构。它们都可以通过包含 <queue> 头文件来使用。 queue 是一种先进先出（FIFO）的数据结构，支持在队尾插入元素，在队头取出元素。queue 的内部实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值