STL—stack&&queue

• 编程语言

一、stack

1.stack的介绍

stack介绍文档 https://legacy.cplusplus.com/reference/stack/stack/?kw=stack

STL---stack&&queue

1. stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。

2. stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。

3. stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：

empty：判空操作

back：获取尾部元素操作

push_back：尾部插入元素操作

pop_back：尾部删除元素操作

4. 标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器，默认情况下使用deque。

栈的结构

STL---stack&&queue

最大特点：后进先出 LIFO

1.2 stack的用法

函数说明

接口说明

stack()

构造空的栈

empty()

检测
stack
是否为空

size()

返回
stack
中元素的个数

top()

返回栈顶元素的引用

push()

将元素
val
压入
stack
中

pop()

将
stack
中尾部的元素弹出 

#include#includeusing namespace std;void test1(){	stack st;	st.push(1);//插入5个数	st.push(2);	st.push(3);	st.push(4);	st.push(5);	cout << "size:"<<st.size() << endl;	while (!st.empty())	{		cout << st.top() << " ";//取栈顶元素		st.pop();//删除栈顶元素；	}	cout << endl;}int main(){	test1();	return 0;}

STL---stack&&queue

1.3stack模拟实现

栈的模拟实现不像之前用C语言那样一步步实现的，我们可以看到官方文档stack的参数是有两个的，一个是T，一个是Container=deque。

STL---stack&&queue

什么意思呢？这个Container是适配器的意思。给了缺省值deque。deque是一个双端队列。

deque(
双端队列
)
：是一种双开口的
”
连续
”
空间的数据结构
，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)
，与
vector
比较，头插效率高，不需要搬移元素；与
list
比较，空间利用率比较高。我们之前在C语言实现栈是实现的数组栈，在这里，直接可以用deque实现，它能满足list和vector的功能，所以，我们模拟实现stack的接口就方便多了，直接调用这个适配器的接口就可以。如果我们不想用deque这个适配器，我们也可以换成vector或者list,实现的时候还是调用vector/list的接口就可以了。

我们可以看到deque的接口：

STL---stack&&queue

STL---stack&&queue

接下来，我们试着实现栈 

#include
#include
namespace A
{
	template <class T, class Container = deque>
	class stack
	{
	public:
		void push(const T& x)//插入
		{
			_con.push_back(x);
		}
		void pop()//删除
		{
			_con.pop_back();

		}
		bool empty()//判空
		{
			return _con.empty();
		}
		int size()//栈数据个数
		{
			return _com.size();
		}
		const T& top()//栈顶元素
		{
			return _con.back();
		}
	private:
		Container _con;//deque适配器
	};
}

我们用命名空间把自己实现的stack封起来，避免与库里面的stack冲突，然后测试接口。

#include
void test2()
{
	A::stack st;
	st.push(10);
	st.push(20);
	st.push(30);
	st.push(40);
	cout << "size:" << st.size() << endl;
	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
	cout << endl;
}
int main()
{
	test2();
	return 0;
}

STL---stack&&queue

我们看到程序正常运行，结果也符合预期。

二、queue

队列这里分两种，一个是我们之前就认识的队列queue,还有一个是priority_queue优先级队列。

STL---stack&&queue

2.1queue

2.1.1queue介绍

queue文档介绍 https://legacy.cplusplus.com/reference/queue/queue/ 

STL---stack&&queue

1.
队列是一种容器适配器，专门用于在
FIFO
上下文
(
先进先出
)
中操作，其中从容器一端插入元素，另一端提取元素。

2.
队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，
queue
提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。

3.
底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:

empty
：检测队列是否为空

size
：返回队列中有效元素的个数

front
：返回队头元素的引用

back
：返回队尾元素的引用

push_back
：在队列尾部入队列

pop_front
：在队列头部出队列

4.
标准容器类
deque
和
list
满足了这些要求。默认情况下，如果没有为
queue
实例化指定容器类，则使用标准容器deque
。

特点：先进先出 FIFO

2.1.2queue用法

queue接口

函数声明

接口说明

queue()

构造空的队列

empty()

检测队列是否为空，是返回
true
，否则返回
false

size()

返回队列中有效元素的个数

front()

返回队头元素的引用

back()

返回队尾元素的引用

push()

在队尾将元素
val
入队列

pop()

将队头元素出队列

接口使用演示

void test3()
{
	queue q;
	q.push(10);
	q.push(20);
	q.push(30);
	q.push(40);
	q.push(50);
	cout << "size:"<<q.size() << endl;//队内数据个数
	while (!q.empty())
	{
		cout << q.front() << " ";//打印队首元素
		q.pop();//删除队首元素；
	}
	cout << endl;
}

STL---stack&&queue

2.1.3queue模拟实现

queue的模拟实现和stack类似，queue类模板有两个参数，

STL---stack&&queue

我们实现的时候直接调用适配器的接口就可以了。需要注意的是，queue可以使用List实现，但是不能用vctor当适配器，因为queue是尾插，头删，而vector的头删效率太低太低了。

下面我们开始实现。

#include
#include
namespace A
{
	template<class T, class Container = deque>
	class queue
	{
	public:

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

		}
		void pop()
		{
			_con.pop_front();
		}
		bool empty()
		{
			return _con.empty();
		}
		size_t size()
		{
			return _con.size();
		}
		const T& front()
		{
			return _con.front();
		}
		const T& back()
		{
			return _con.back();
		}
	private:
		Container _con;
	};
}

还是一样，我们用命名空间封起来之后测试

void test4()
{
	A::queue q;
	q.push(5);
	q.push(10);
	q.push(15);
	q.push(20);
	cout << "size:" << q.size() << endl;
	while (!q.empty())
	{
		cout << q.front() << " ";
		q.pop();
	}
	cout << endl;
}
int main()
{
  test4();
  return 0;
}

STL---stack&&queue

程序正常运行且结果符合预期。

2.2priority_queue

2.2.1priority_queue介绍

文档介绍 https://legacy.cplusplus.com/reference/queue/priority_queue/

STL---stack&&queue

1.
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。

2.
此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素
(
优先队列中位于顶部的元素)
。

3.
优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，
queue
提供一组特定的成员函数来访问其元素。元素从特定容器的“
尾部
”
弹出，其称为优先队列的顶部。

4.
底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：

empty()
：检测容器是否为空

size()
：返回容器中有效元素个数

front()
：返回容器中第一个元素的引用

push_back()
：在容器尾部插入元素

pop_back()
：删除容器尾部元素

5.
标准容器类
vector
和
deque
满足这些需求。默认情况下，如果没有为特定的
priority_queue
类实例化指定容器类，则使用vector
。

6.
需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、
push_heap
和
pop_heap
来自动完成此操作。

特点：
按照数据优先级出队列（底层是堆，默认大堆）

2.2.2priority_queue用法

优先级队列默认使用vector
作为其底层存储数据的容器，在
vector
上又使用了堆算法将
vector
中元素构造成
堆的结构，因此
priority_queue
就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。

函数声明

接口说明

priority_queue()/priority_queue(first,

last)

构造一个空的优先级队列

empty( )

检测优先级队列是否为空，是返回
true
，否则返回
false

top( )

返回优先级队列中最大
(
最小元素
)
，即堆顶元素

push(x)

返回优先级队列中最大
(
最小元素
)
，即堆顶元素

pop
()

删除优先级队列中最大
(
最小
)
元素，即堆顶元素 

#include#include#inclduevoid test5(){	priority_queue pq;	pq.push(5);	pq.push(1);	pq.push(8);	pq.push(10);	pq.push(-5);	cout <<"size:"<< pq.size() << endl;//输出数据个数	while (!pq.empty())	{		cout << pq.top() << " ";//输出堆顶元素；		pq.pop();//删除堆顶元素	}	cout << endl;}

STL---stack&&queue

2.2.3priority_queue模拟实现

我们可以看到文档中对priority_queue的介绍是三个参数

STL---stack&&queue

怎么比平常多了一个参数，第三个参数是干嘛的呢？

我们说了，优先级队列底层是堆实现的，默认是大堆，如果我们不想用大堆呢？想让数据从小到大以小堆排列怎么办？所以这里的第三个参数就是用来改变默认大小堆的，这里是用仿函数控制的。

我们按照之前的方法把priority_queue的基础接口写出来。

namespace A
{
   template<class T, class Container = vector>
class priority_queue
{
public:
	
	void push(const T& x)
	{
		_con.push_back(x);
	}
	void pop()
	{
		_con.pop_back();
	}
	size_t size()
	{
		return _con.size();
	}
	bool empty()
	{
		return _con.empty();
	}
	T& top()
	{
		return _con[0];
	}
private:
	Container _con;
};
}

然后我们看，优先级队列的底层是堆，那插入一个数据和删除一个数据之后都需要保证仍然是堆，所以我们还需要写出堆的两个重要组成——向上调整和向下调整。默认是大堆Less，所以我们按照库里面的习惯认为Less是大堆，建大堆。

void adjust_up(size_t child)
{
	size_t parent = (child - 1) / 2;
	while (child > 0)
	{
		if (_con[parent] < _con[child])
		{
			std::swap(_con[child], _con[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
	else
	{
		break;
	}
	}
}
void adjust_down(size_t parent)
{
	size_t child = parent * 2 + 1;;
	while (child < _con.size())
	{
		if (child + 1 < _con.size() && _con[child] < _con[child+1])
		{
			child++;
		}
		if (_con[parent] < _con[child])
		{
			std::swap(_con[child], _con[parent]);
			parent = child;
			child = parent * 2 + 1;;
		}
		else
		{
			break;
		}
	}
}

然后再补全push和pop两个接口。

void push(const T& x)
{
	_con.push_back(x);
	adjust_up(_con.size() - 1);
}
void pop()
{
	std::swap(_con[0], _con[_con.size() - 1]);
	_con.pop_back();
	adjust_down(0);
}

这种写法是默认大堆的写法，如果我们想建小堆呢？再写一个小堆的向上和向下调整吗？

这样太麻烦，C++语言非常忌讳重复代码，所以我们这里用仿函数解决。

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

然后我们可以给priority_queue的参数传第三个参数Compare

template<class T, class Container = vector, class Compare = Less>

这样，默认是大堆Compare=Less,如果想建小堆，直接可以把Less换成Greater;

然后把向上调整和向下调整部分父子比较部分可以用仿函数比较

STL---stack&&queue

STL---stack&&queue

这样就好了。

修改之后的完整代码为

namespace A
{
template
struct Less
{
	bool operator()(const T& x, const T& y)
	{
		return x < y;
	}
};
template
struct Greater
{
	bool operator()(const T& x, const T& y)
	{
		return x > y;
	}
};
template<class T, class Container = vector, class Compare = Less>
class priority_queue
{
public:
	void adjust_up(size_t child)
	{
		Compare com;
		size_t parent = (child - 1) / 2;
		while (child > 0)
		{
			if (com(_con[parent], _con[child]))
			{
				std::swap(_con[child], _con[parent]);
				child = parent;
				parent = (child - 1) / 2;
			}
			else
			{
				break;
			}
		}
	}
	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]))
			{
				std::swap(_con[child], _con[parent]);
				parent = child;
				child = parent * 2 + 1;;
			}
			else
			{
				break;
			}
		}
	}
	void push(const T& x)
	{
		_con.push_back(x);
		adjust_up(_con.size() - 1);
	}
	void pop()
	{
		std::swap(_con[0], _con[_con.size() - 1]);
		_con.pop_back();
		adjust_down(0);
	}
	size_t size()
	{
		return _con.size();
	}
	bool empty()
	{
		return _con.empty();
	}
	T& top()
	{
		return _con[0];
	}
private:
	Container _con;
};
}

我们测试

void test6()
{
	A::priority_queue<int,vector,A::Greater> pq;//小堆
	pq.push(10);
	pq.push(1);
	pq.push(-10);
	pq.push(100);
	cout << "size:" << pq.size() << endl;
	while (!pq.empty())
	{
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;

}

STL---stack&&queue

程序正常运行且结果与预期相符

好啦，这次到这里就结束了，期待下次和大家分享！

本文来自网络，不代表协通编程立场，如若转载，请注明出处：https://net2asp.com/eff319c762.html

赞 (0)
« 上一篇 1天前
下一篇 » 1天前

相关推荐