stack,queue和priority_queue

最新推荐文章于 2025-12-01 22:20:41 发布

原创最新推荐文章于 2025-12-01 22:20:41 发布 · 317 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#算法

stack

stack栈具有后进先出的特点

#pragma once
#include<iostream>
#include<vector>
#include<list>
#include<queue>
using namespace std;
namespace rmrf
{
	template<class T, class Container=deque<T>>
	class stack
	{
	public:
		bool empty()const
		{
			return _con.empty();
		}
		size_t size()const
		{
			return _con.size();
		}
		const T& top()const
		{
			return _con.back();
		}
		void push_back(const T& x)
		{
			_con.push_back(x);
		}
		void pop()
		{
			_con.pop_back();
		}
	private:
		Container _con;
	};
	void test()
	{
		stack<int,string> s;
		s.push_back(1);
		s.push_back(2);
		s.push_back(3);
		s.push_back(4);
		while(!s.empty())
		{
			cout << s.top() << " ";
			s.pop();
}
	}
	
}

queue

queue队列具有先进先出的特点

#pragma once
#include<iostream>
#include<vector>
#include<list>
#include<queue>
using namespace std;
namespace rmrf
{
	template<class T, class Container>
	class queue
	{
	public:
		bool empty()const
		{
			return _con.empty();
		}
		size_t size()const
		{
			return _con.size();
		}
		const T&  front()const
		{
			return _con.front();
		}
		const T& back()const
		{
			return _con.back();
		}
		void push(const T& x)
		{
			_con.push_back(x);
		}
		void pop()
		{
			_con.pop_front();
		}
	private:
		Container _con;
	};
	void test1()
	{
		queue<int, list<int>> s;
		s.push(1);
		s.push(2);
		s.push(3);
		s.push(4);
		while (!s.empty())
		{
			cout << s.front() << " ";
			s.pop();
		}
	}

}

适配器

stack和queue都将deque作为其容器适配器

deque

deque叫做双端队列，是一种双开口的连续的的数据结构，适合在头部和尾部进行插入和删除操作，它融合了vector和list的优点

vector的优点：可以访问任意位置的下标

vector的缺点：头部的插入删除极为不便，扩容效率低，空间浪费

list的优点：任意位置的插入删除，按需申请释放空间

list的缺点：不能随机访问数的位置

deque和vector,list做适配器对比

priority_queue

默认是大堆的优先级高———默认给的仿函数是less

如果要控制小堆的优先级高——给一个greater的仿函数

//用vector作为底层容器，内部构造大堆结构。
priority_queue<int, vector<int>, less<int>> q1;
//用vector作为底层容器，内部构造小堆结构。
priority_queue<int, vector<int>, greater<int>> q2;
//不指定底层容器和内部需要构造的堆结构。
priority_queue<int> q3;

构造函数

一种是默认的构造函数，一种是迭代器区间构造的构造函数（构造成大堆）


priority_queue()
		{

		}
		template<class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
			:_con(first, last)
		{
			for (int i = (_con.size() - 1 - 1) / 2; i >= 0; i--)
			{
				adjust_down(i);
			}
	}

仿函数

template<class T>
	struct Less
	{
		bool operator()(const T& x, const T& y)const
		{
			return x > y;
		}
	};
	template<class T>
	struct Greater
	{
		bool operator()(const T& x, const T& y)const
		{
			return x < y;
		}
	};

push函数

template<class T, class Container = vector<T>,class Compare=Less<T>>
void adjust_up(size_t child)
		{
			Compare com;
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				if (com(_con[parent] ,_con[child] ))
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;

				}
				else
				{
					break;
				}
			}
		}
void push(const T& x)
		{
			_con.push_back(x);
			adjust_up(_con.size() - 1);
		}

和堆排序那里一样，尾插之后，向上调整再次构成堆。因为不能有用户自己来决定排序，所以传个仿函数，利用仿函数来进行比较，这里的less是小于，所以要自己调整顺序

pop函数

template<class T, class Container = vector<T>,class Compare=Less<T>>
void adjust_down(size_t parent)
		{
			Compare com;
			size_t child = parent * 2 + 1;

			while (child < _con.size())
			{
				if (child + 1 < _con.size() &&  com(_con[child],_con[child + 1]))
				{
					++child;
				}
				if (com(_con[parent],_con[child]))
				{
					swap(_con[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}
void pop()
		{
			assert(!_con.empty());
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();
			adjust_down(0);
		}

排升序建大堆，此时第一个数据就是最大的，如果直接删掉top位置，只能第二个数堆顶，此时直接打破了原来的大堆结构，所以先将top位置与倒数第一个数据进行交换，然后删掉top位置，再自上向下进行调整

其余函数

	const T& top()
		{
			return _con[0];
		}
		size_t size()
		{
			return _con.size();
		}
		bool empty()
		{
			return _con.empty();
		}

直接进行库里的调用即可

自己构造仿函数

当函数不用less或greater时，拿date类做例子，当date类比较大小就需要自己去写

当date类需要将时间排序

class Date
	{
	public:
		Date(int year = 1900, int month = 1, int day = 1)
			: _year(year)
			, _month(month)
			, _day(day)
		{}

		bool operator<(const Date& d)const
		{
			return (_year < d._year) ||
				(_year == d._year && _month < d._month) ||
				(_year == d._year && _month == d._month && _day < d._day);
		}

		bool operator>(const Date& d)const
		{
			return (_year > d._year) ||
				(_year == d._year && _month > d._month) ||
				(_year == d._year && _month == d._month && _day > d._day);
		}

		friend ostream& operator<<(ostream& _cout, const Date& d);
	private:
		int _year;
		int _month;
		int _day;
	};
	ostream& operator<<(ostream & _cout, const Date & d)
	{
		_cout << d._year << "-" << d._month << "-" << d._day << endl;
		return _cout;
	}
		priority_queue<Date,vector<Date>> pq;去调用

当我们只有date*的指针，这时自己重载的大于小于就不管用了，就需要自己去写一个专门针对指针的仿函数、

using namespace std;
	class Date
	{
		friend struct LessPDate;
	public:
		Date(int year = 1900, int month = 1, int day = 1)
			: _year(year)
			, _month(month)
			, _day(day)
		{}

		bool operator<(const Date& d)const
		{
			return (_year < d._year) ||
				(_year == d._year && _month < d._month) ||
				(_year == d._year && _month == d._month && _day < d._day);
		}

		bool operator>(const Date& d)const
		{
			return (_year > d._year) ||
				(_year == d._year && _month > d._month) ||
				(_year == d._year && _month == d._month && _day > d._day);
		}

		friend ostream& operator<<(ostream& _cout, const Date& d);
	private:
		int _year;
		int _month;
		int _day;
	};
	ostream& operator<<(ostream & _cout, const Date & d)
	{
		_cout << d._year << "-" << d._month << "-" << d._day << endl;
		return _cout;
	}
struct LessPDate
	{
		bool operator()(Date* x, Date* y)
		{
			return *x < *y;
		}
	};
	void test_priority_queue2()
	{
		priority_queue<Date*,vector<Date*>,LessPDate> pq;
		pq.push(new  Date(2022, 3, 26));
		pq.push(new  Date(2021, 10, 26));
		pq.push(new  Date(2023, 3, 26));
		while (!pq.empty())
		{
			cout << *pq.top() ;
			pq.pop();
		}
		cout << endl;
	}