【C++】stack，queue，容器适配器

目录

1.容器适配器

2.栈（stack）

2.1栈的介绍

2.2栈的操作 

2.3stack模拟实现

3.队列（queue）

3.1队列操作

3.2queue模拟实现 

4.deque (双端数组）

4.1deque的优缺点 ；

5.priority_queue(优先级对列）

6.仿函数  

---

1. 引言：

在使用stack和queue是先加上头文件#include ， #include

在写下面内容时我们先了解一下容器适配器。

容器适配器：

容器适配器中的“适配器”，和生活中常见的电源适配器中“适配器”的含义非常接近。我们知道，无论是电脑、手机还是其它电器，充电时都无法直接使用 220V 的交流电，为了方便用户使用，各个电器厂商都会提供一个适用于自己产品的电源线，它可以将 220V 的交流电转换成适合电器使用的低压直流电。

在我们的角度看：电源线扮演的角色就是将原本不适用的交流电变得适用，因此其又被称为电源适配器。

1.容器适配器

就比如我们写个类A

    class A{
    public:
        void v1(){}
        void 22(){}
        void v3(){}
        void v4(){}
        void v5(){}
    };

但是现在我们需要设计一个模板 B，但发现，其实只需要组合一下模块 A中的 v1()、v2()、v3()，就可以实现模板 B 需要的功能。其中 v1() 和v2()一起使用，而 v3() 和 v4() 和v5()需要组合起来使用，如下所示：

class B{
private:
A * a;
public:
void func1(){
a->v1();
a->v2();
}
void func2(){
a->f3();
a->f4();
a->f5();
}

• 可以看到，就如同是电源适配器将不适用的交流电变得适用一样，模板 B 将不适合直接拿来用的模板 A 变得适用了，因此我们可以将模板 B 称为 B 适配器。
• 简单的理解容器适配器就是将不适用的序列式容器（包括 vector、deque 和 list）变得适用。容器适配器的底层实现和模板 A、B 的关系是完全相同的，即通过封装某个序列式容器，并重新组合该容器中包含的成员函数，使其满足某些特定场景的需要。
• 容器适配器本质上还是容器，只不过此容器模板类的实现，利用了大量其它基础容器模板类中已经写好的成员函数。当然，如果必要的话，容器适配器中也可以自创新的成员函数。

2.栈（stack）

2.1栈的介绍

在数据结构那我们知道了栈的规则：后进先出，C++中的容器适配器stack也遵循这个后进先出规则。

2.2栈的操作 

操作类型	相应功能
empty()	进行判空操作
size()	返回栈中元素个数
push()	将元素压入栈中操作
back()	弹出尾部数据操作
top()	返回栈顶的元素，但不删除

直接上代码

void test_stack()
{
	stack s;
	s.push(1);
	s.push(2);
	s.push(3);
	s.push(4);
	s.push(5);     //1 2 3 4 5
	while (!s.empty())
	{
		cout << s.top() << endl;               // 5 4 3 2 1
		s.pop();   //必须弹出最上面的数据
	}
	cout << "栈内的元素的个数为：" << s.size() << endl;

}
int main()
{
	test_stack();
}

接下来我们用vector容器先进行一波模拟实现 (下面的代码是在新创建的Stack.h头文件中写的)

2.3stack模拟实现

pragma once
namespace st
{
	template
	class Stack
	{
	public:
		void push(const T& x)  //压栈
		{
			_con.push_back(x);   //用vector实现的，有这个操作
		}
		void pop()  //出栈
		{
			_con.pop_back();
		}
		T& top()   //返回栈顶数
		{
			return _con.back(); //返回尾部元素
		}
		bool empty()
		{
			return _con.empty();
		}
		size_t size()
		{
			return _con.size();
		}
	private:
		vector _con;
	};
}

 严格意义来说这个用vector容器写的代码根本就不是容器适配器，他太单调，只适合一种。

如果我们想写成容器适配器类型就要改vector为基础类型。

namespace st2
{
	template
	class Stack
	{
	public:
		void push(const T& x)  //压栈
		{
			_con.push_back(x);   //用vector实现的，有这个操作
		}
		void pop()  //出栈
		{
			_con.pop_back();
		}
		T& top()   //返回栈顶数
		{
			return _con.back(); //返回尾部元素
		}
		bool empty()
		{
			return _con.empty();
		}
		size_t size()
		{
			return _con.size();
		}
	private:
		//vector _con;
		Container _con;
	};
}

 这多出个模板参数，所以我们也要加上，而且不仅vector容器可以，list也可以，所以这个就是一个容器适配器了。

3.队列（queue）

 队列就是先进先出，没啥特别的意思。

3.1队列操作

操作类型	相应功能
queue()	构造空的队列
empty()	检测队列是否为空，是返回true，不是返回false
size()	返回队列中有效元素的个数
front()	返回对头元素的引用
back()	返回队尾元素的引用
push()	在队尾将元素val入队列
pop()	将对头元素出队列

这个跟stack大差不差的。

void test_queue()
{
	queue q;
	for (int i = 3; i < 9; i++)
	{
		q.push(i);
	}
	cout << q.size() << endl;//6
	cout << q.back() << endl;//8
	while (!q.empty())
	{
		cout << q.front() << " ";//3 4 5 6 7 8
		q.pop();
	}
}

注意我们要向遍历对列就要将对首的数据遍历后出队，要不后面的啥时候才是对首呢？怎么会轮到他呢？

3.2queue模拟实现 

这个跟上面的stack的实现如出一辙。不废话直接上。

namespace que
{
	template
	class Queue
	{
	public:
		//入列
		void push(const T& x)
		{
			_con.push_back(x);
		}
		//出列
		void pop()
		{
			_con.pop_front();
		}
		//取队列顶部数据（取队头数据）
		const T& front()
		{
			return _con.front();//返回队头数据
		}
		//取队列尾部数据（取队尾数据）
		const T& back()
		{
			return _con.back();//返回队尾数据
		}
		//获取有效数据个数
		size_t size()
		{
			return _con.size();
		}
		//判空
		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
}

这里的模板用list实现，不能用vector了，因为模拟实现有一项返回对头数据数据是通过list底层实现的，vectorr没有这个操作接口。就是vector没有pop_front这一底层功能 。

4.deque (双端数组）

刚才模拟实现queue是发现用vector模板竟然不能用我们在想一下vector和list.

• vector的底层：顺序表，插入删除时需要挪动数据，效率低。
• list的底层：链表，不能随机进行访问。

那我们能不能找一种既能支持随机访问又不需要挪动数据的容器呢？

让我们欢迎deque.

4.1deque的优缺点 ；

特点：

1. 不像list是单个结点而是一小块连续空间。可以进行某些随机访问。
2. 不像vector是整块连续空间而是多个小块连续空间插入删除时有的不需要挪动数据。
3. 如果每个buffer(空间段）的大小一样，就能算出数据具体在那个位置。

我们要求i在那 ：

1.(i-第一个buffer中的个数）/buffer中的个数----算出在第几个buffer.

2.(i-第一个buffer中的个数）%buffer中的个数-----算出是第几个数据。

缺点：

1. 不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，
2. 不适合大量的头部和中间插入删除，也不适合大量的随机访问。而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构。

 迭代器

 足足四个指针，所以它进行头步和尾部的操作十分遍历。过程有点繁杂。

 代码实现 

(就先写这几个吧，各位有兴趣可以完善一下)

int main()
{
	deque d;
	for (int i = 0; i < 10; i++)
	{
		d.push_back(i);
	}
	//带参构造
	deque d1(d.begin(), d.end()); //0-9
	deque d2(3, 66); //66 66 66
	deque d3(d); //0-9

	d.push_front(-1);  //-1，0 1 2...9    头插
	d.push_front(-2);   //-2 -1...9    尾插
	d.pop_back();     //-2 -1...8         尾删
	d.pop_front();     //-1...8         头删

	//普通迭代器
	deque::iterator it = d.begin();
	while ( it != d.end()) {

		cout << *it;
		cout << " ";
		it++;
	}

	
}

结论：

1. 头尾插入删除deque非常适合，相较于list和vector,其更适合做stack和queue的适配器。
2. 中间插入删除多用list(用deque简直就是灾难）。
3. 随机访问用vector 。

5.priority_queue(优先级对列）

优先级队列（priority queue） 是0个或多个元素的集合，每个元素都有一个优先权，对优先级队列执行的操作有（1）入队列（2）出队列 （3）取队首元素 ，一般情况下，查找操作用来搜索优先权最大的元素，删除操作用来删除该元素 。对于优先权相同的元素，可按先进先出次序处理或按任意优先权进行。优先级队列的实现方式有很多，但常见的是使用堆来构建。

其实优先级队列和一般队列的操作方式没啥大的区别。

它的底层原理是堆。

优先级队列和队列区别：

• 相同之处：对优先级相同的元素和普通队列一样遵循“先进先出”的原则、
• 不同之处：在于优先级队列的出队列操作不是把队头元素出队列，而是把队列中优先级最高的数据元素出队列。

优先级队列支持以下操作：

• empty()：检测容器是否为空
• size()：返回容器中有效元素个数
• front()：返回容器中第一个元素的引用
• push_back()：在容器尾部插入元素
• pop_back()：删除容器尾部元素

它的具体函数操作如下：

函数声明	函数接口
priority_queue()/priority_queue(first,last)	构造空优先级队列
empt()	检测优先级队列是否为空，是返回true，否则返回false
top()	返回优先级队列中最大(最小元素)，即堆顶元素
push()	在优先级队列中插入元素
pop()	删除优先级队列中最大(最小)元素，即堆顶元素

void test_priority_queue()
{
	priority_queue pq;
	pq.push(1);
	pq.push(7);
	pq.push(4);
	pq.push(8);
	pq.push(2);
	pq.push(5);
	//不支持遍历只能一个一个出的访问
	while (!pq.empty())  //不为空进入循环，所以加上！
	{
		cout << pq.top() << " ";  //8 7 5 4 2 1
		pq.pop();
	}
	cout << endl;
}

我是随机输的值，但是打印的结果是从大到小，说明这个底层是大堆了。

那我们用小堆咋实现。（第一个代码不是小堆，而是另一种构造方式）

void test_priority_queue2()
{
	int a[] = { 0,3,5,7,1,8,3,9 };
	priority_queue pq2(a, a + sizeof(a) / sizeof(int));
	while (!pq2.empty())
	{
		cout << pq2.top() << " ";
		pq2.pop();
	}
	cout << endl;
//小堆实现
	int b[] = { 0,3,5,7,1,8,3,9 };
	priority_queue, greater> pq3(b, b + sizeof(b) / sizeof(int));
	while (!pq3.empty())
	{
		cout << pq3.top() << " ";
		pq3.pop();
	}
	cout << endl;
}

 如果是小堆，第三个参数是greater，大堆，第三个参数是less,也不知道设计者咋想的。

• 大堆构造结构实现：

riority_queue, less> q1;

• 小堆构造结构实现·：

priority_queue, greater> q2;

• 默认构造结构实现：

priority_queue pq;

模拟实现：

#pragma once
#include   //解决std空间没有swap的错误
namespace pue
{
	template
	class priority_queue
	{
	public: 
		void adjust_up(size_t child)     //小堆，从下往上调的
		{
			size_t parent = (child - 1) / 2;
			while (child > 0)   //只能到根节点处了，再交换就错了
			{
				if (_con[child] > _con[parent])
				{
					std::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);   //从下往上调整。
		}

		void adjust_down(size_t parent)   //大堆，所以是从上往下调的
		{
			size_t child = 2 * parent + 1;
			while (parent < _con.size())
			{
				if (child + 1 < _con.size() && _con[child + 1] > _con[child])
				{
					child++;
				}
				if (_con[child] > _con[parent])
				{
					std::swap(_con[child], _con[parent]);
					parent = child;
					child = 2 * parent + 1;
				}
				else
				{
					break;
				}
			}
		}
		void pop()
		{
			std::swap(_con[0], _con[_con.size() - 1]); //先交换首尾
				_con.pop_back();
			adjust_down(0);                 //再从上往下调
		}

		//取对顶数据
		const T& top()
		{
			return _con[0];
		}
		//获取size有效数据个数
		size_t size()
		{
			return _con.size();
		}
		//判空
		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};

}
	

 

 有的兄弟们肯定对对上下建堆有点不解，为啥传入的是长度而不是首，尾的下标。

切记：

• 堆的表现形式是二叉树
•  堆的物理基础是数组

我们要进行尾插不就是在数组的最后插入吗，不就要传数组长度吗？

6.仿函数  

C++中有些地方会用到函数指针，但是通过C语言我们了解到函数指针过于复杂，所以设计人员就想找东西去替代函数指针，那久用到了仿函数。

重载函数调用操作符的类，其对象常称为函数对象（function object），即它们是行为类似函数对象。又称仿函数。

仿函数我们可以把它理解为“仿造函数”。但他不是函数，我们可以把它理解为是类。就是重载operate（）。

优点：

• 1.仿函数可有拥有自己的数据成员和成员变量，这意味着这意味着仿函数拥有状态。这在一般函数中是不可能的。
• 2.每个仿函数有自己的型别。
• 3.仿函数通常比一般函数有更好的速度。