【C++初阶】--- deque容器和stack、queue、priority_queue三个容器适配器的模拟实现

已于 2025-06-26 19:03:15 修改
阅读量903 收藏 21
点赞数 25
CC 4.0 BY-SA版权
文章标签： c++ java 开发语言
于 2025-04-23 15:44:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Wangshijie1015/article/details/147403941

1.容器适配器

1.1什么是适配器

适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。

1.2STL标准库中stack和queue的底层结构

虽然stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和队列只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque，
由于stack和queue是通过其他容器适配而成，所以stack和queue称为容器适配器。
在这里插入图片描述
在这里插入图片描述

1.3deque的简单介绍

1.3.1deque的原理介绍

deque(双端队列)：是一种双开口的"连续"空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要移元素；与list比较，空间利用率比较高。
在这里插入图片描述
deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组，其底层结构如下图所示：

在这里插入图片描述
双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落在了deque的迭代器身上，因此deque的迭代器设计就比较复杂，如下图所示：
在这里插入图片描述
那deque是如何借助其迭代器维护其假想连续的结构呢？在这里插入图片描述

1.3.2deque的缺陷

优点：

  1. 与vector比较，deque的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率是必vector高的。
  2. 与list比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。

缺点：
1.但是，deque有一个致命缺陷：不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构
在这里插入图片描述

1.3.3选择deque作为stack和queue的底层默认容器的原因

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

2.stack和queue的模拟实现

  1. stack和queue的模拟实现思路一样，都是通过容器适配而成
  2. 容器的模板参数Container给出容器deque作为底层的默认容器
  3. 使用的过程中也可以自己指定容器，如vecctor和list，不过需要注意的是vector不支持push_front()和pop_front()，但如果你容器传的是vector但不调用这两个函数的时候，编译器依旧不会报错，这里就涉及到按需实例化的概念了，我们模拟实现的这个stack和queue都是模板，而类模板实例化时，按需实例化，使用哪些成员函数就实例化哪些，不会全实例化
  4. stack和queue的方式实现在底层都是转为调用适配容器，只要容器能够满足所有的转调用操作都可以充当适配容器
  5. 由于stack和queue是通过其他容器适配而成，所以stack和queue称为容器适配器
//栈：后进先出
template<class T, class Container = deque<T>>
class stack
{
public:
	stack()
	{}

	void push(const T& x)
	{
		_con.push_back(x);
	}

	void pop()
	{
		_con.pop_back();
	}

	T& top()
	{
		return _con.back();
	}

	const T& top() const
	{
		return _con.back();
	}

	size_t size() const
	{
		return _con.size();
	}

	bool empty() const
	{
		return _con.empty();
	}

private:
	Container _con;
};

//队列:先进先出
template<class T, class Container = deque<T>>
class queue
{
public:
	queue()
	{}

	void push(const T& x)
	{
		_con.push_back(x);
	}

	void pop()
	{
		_con.pop_front();
	}

	T& front()
	{
		return _con.front();
	}

	T& back()
	{
		return _con.back();
	}

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

	const T& back() const
	{
		return _con.back();
	}

	size_t size() const
	{
		return _con.size();
	}

	bool empty() const
	{
		return _con.empty();
	}

private:
	Container _con;
};

3.priority_queue模拟实现

priority_queue 是 C++ STL 中的一种容器适配器，它提供了一种优先队列的数据结构实现。优先队列是一种特殊的队列，其中元素按照优先级顺序出队，而不是按照先进先出的顺序。priority_queue的底层结构就是堆，库里默认实现是大堆。

3.1size()、top()、empty()

size_t size() const
{
	return _con.size();
}

//返回堆顶元素
const T& top() const
{
	return _con[0];
}

bool empty() const
{
	return _con.empty();
}

3.2仿函数

仿函数本质是一个类，这个类重载operator()，他的对象可以像函数一样使用。
在这里插入图片描述

3.3Less和Greater

Less和Greater是两个仿函数，用于作为priority_queue模板参数的缺省值,因为后续调整建堆的时候涉及元素之间的比较，而比较就会影响建的是大堆还是小堆，我们实现这两个仿函数的作用就是希望传Less的时候建的是大堆，传Greater的时候建的是小堆。

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

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

3.4基本框架

T是堆中存储的元素类型，Container给出vector作为底层的默认容器，Compare默认给的是Less,Less是个仿函数
_con是容器实例化的对象，_com是Compare模板实例化的对象

//优先级队列，其实就是堆(默认是大堆)
template<class T, class Container = vector<T>, class Compare = Less<T>>
class priority_queue
{
private:
	Container _con;
	Compare _com;
};

3.5插入元素

  1. 将元素先尾插
  2. 尾插后容器中的元素可能并不符合堆结构，所以我们要对其进行向上调整建堆
void AdjustUp(int child)
{

	int parent = (child - 1) / 2;

	//0就是根节点了
	while (child)
	{
		//if (_con[child] > _con[parent])
		if (_com(_con[parent],_con[child]))
		{
			swap(_con[parent], _con[child]);
			child = parent;
			parent = (child - 1) / 2;
		}

		else
			return;
	}
}

void push(const T& x)
{
	_con.push_back(x);
	//向上调整
	AdjustUp(_con.size() - 1);
}

3.6删除首元素

  1. 删除首元素需要先交换首位元素。
  2. 删除尾元素。
  3. 首位元素交换后，容器中的元素并不符合堆结构，我们需要向下调整建堆。
void AdjustDown(int parent)
{
	//先假设左孩子是需要交换的那个
	int child = parent * 2 + 1;

	//child>=_con.size()说明孩子不存在，parent是叶子节点
	while (child < _con.size())
	{
		//if (child + 1 < size() && _con[child + 1] > _con[child])
		if (child + 1 < _con.size() && _com(_con[child], _con[child + 1]))
		{
			child += 1;
		}

		//if (child < size() && _con[parent] < _con[child])
		if (_com(_con[parent],_con[child]))
		{
			swap(_con[parent], _con[child]);
			parent = child;
			child = parent * 2 + 1;
		}

		else
			return;
	}
}
		
void pop()
{
	if (_con.empty())
		return;

	//交换首尾元素，删除尾元素，重新建堆
	swap(_con[0], _con[size() - 1]);
	_con.pop_back();
	AdjustDown(0);
}

4.需要自己实现仿函数的情况

4.1类类型不支持比较大小

这里我们优先级队列中的数据类型是Date类型，但自定义类型不支持比较大小，所以我们需要实现仿函数对其进行比较或者在类中重载比较运算符。

#include<iostream>
#include<queue>
using namespace std;

class Date
{
	friend ostream& operator<<(ostream& _out, const Date& d);
public:
	Date(int year = 1900, int month = 10, int day=15)
		:_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);
	}

private:
	int _year;
	int _month;
	int _day;
};

ostream& operator<<(ostream& _out, const Date& d)
{
	_out << d._year << "-" << d._month << "-" << d._day;
	return _out;
}

int main()
{
	priority_queue<Date> q1;
	q1.push(Date(2018, 10, 29));
	q1.push(Date(2018, 10, 28));
	q1.push(Date(2018, 10, 30));

	cout << q1.top() << endl;
	q1.pop();

	cout << q1.top() << endl;
	q1.pop();

	cout << q1.top() << endl;
	q1.pop();
	cout << endl;
}

4.2比较结果不是我们想要的

这次我们优先级队列中的数据类型不是Date，而是Date*，虽然我们在Date类中重载了比较运算符，但是他实际运行的时候比较的是地址，而我们的数据是new出来的，地址也是随机的， 先new的不一定大或者小，因此结果显然是错的。
所以我们需要实现一个仿函数从而实现正确的比较。

#include<iostream>
#include<queue>
using namespace std;

class Date
{
	friend ostream& operator<<(ostream& _out, const Date& d);
public:
	Date(int year = 1900, int month = 10, int day=15)
		:_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);
	}

private:
	int _year;
	int _month;
	int _day;
};

ostream& operator<<(ostream& _out, const Date& d)
{
	_out << d._year << "-" << d._month << "-" << d._day;
	return _out;
}

class DateLess
{
	//记得公开
public:
	bool operator()(Date* d1, Date* d2)
	{
		return *d1 < *d2;
	}
};


int main()
{
	priority_queue<Date*,vector<Date*>,DateLess> q2;
	q2.push(new Date(2018, 10, 29));
	q2.push(new Date(2018, 10, 28));
	q2.push(new Date(2018, 10, 30));

	cout << *q2.top() << endl;
	q2.pop();

	cout << *q2.top() << endl;
	q2.pop();

	cout << *q2.top() << endl;
	q2.pop();

	return 0;
}
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值