STL--stack queue deque

stack

一、stack介绍

stack是一种容器适配器，专门设计用于后进先出，其中元素仅从容器的一端插入和提取

template <class T, class Container = deque<T> > class stack;

二、stack接口

函数名称	功能说明
empty	判断容器是否为空
size	返回容器容量大小
top	返回栈顶数据
push	从栈顶插入元素
pop	删除栈顶元素

三、stack模拟实现

#pragma once
#include<iostream>
#include<vector>
#include<list>
using std::cout;
using std::endl;

namespace mystack
{
	// 适配器模式/配接器
	template<class T,class Container = std::vector<T>>
	//默认为容器栈
	//类模板半缺省，默认为数组栈
	class stack
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}
		void pop()
		{
			_con.pop_back();
		}
		const T& top()
		{
			return _con.back();
		}
		bool size()
		{
			return _con.size();
		}
		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
		//通过已有容器适配，从而实现链式栈，数组栈
		//vector<T> _v;
	};



	void test_1()
	{
		stack<int, std::vector<int>> st1;
		st1.push(1);
		st1.push(2);
		st1.push(3);
		st1.push(4);
		st1.push(5);
		while (!st1.empty())
		{
			cout << st1.top() << " ";
			st1.pop();
		}
		cout << endl;
	}
}

queue

一、queue介绍

queue是一种容器适配器，专门用于在先进先出操作，其中从容器一端插入元素，另一端提取元素

template <class T, class Container = deque<T> > class queue;

二、queue接口 

函数名称	功能说明
empty	判断容器是否为空
size	返回容器容量大小
top	返回栈顶数据
push	从栈顶插入元素
pop	删除栈顶元素

三、queue模拟实现

#pragma once
#include<iostream>
#include<vector>
#include<list>
using std::cout;
using std::endl;

namespace myqueue
{
	// 适配器模式/配接器
	template<class T, class Container = std::list<T>>
	//默认为链式队列
	//类模板半缺省，默认为数组栈
	class queue
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}
		void pop()
		{
			_con.pop_back();
		}
		const T& top()
		{
			return _con.back();
		}
		bool size()
		{
			return _con.size();
		}
		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;

	};



	void test_1()
	{
		queue<int> q1;//默认为链式队列
		q1.push(1);
		q1.push(2);
		q1.push(3);
		q1.push(4);
		q1.push(5);
		while (!q1.empty())
		{
			cout << q1.top() << " ";
			q1.pop();
		}
		cout << endl;
	}
}

deque

一、deque介绍

Deque（通常发音为“deck”）是double-e nded queue的不规则首字母缩略词

deque是具有动态大小的序列容器，可以在两端（正面或背面）扩展或收缩

允许通过随机访问迭代器直接访问单个元素，并通过根据需要扩展和收缩容器来自动处理存储。

deque相当于是vector+list。但与vector不同在于，deque不能保证将所有的元素保存在连续的存储位置。deque 容器存储数据的空间是由一段一段等长的连续空间构成，各段空间之间并不一定是连续的，可以位于在内存的不同区域

deque容器通过一个数组来存放各个连续空间的首地址，也就是说deque数组中存放的全是指针，指针指向的连续空间用于存储数据，后面将这款连续区域称为buffer

deque会将每一个连续空间存储满之后，才将数据存放置下一个连续空间

一般用于stack与queue的底层数据结构

优点	缺点
1.相比于vector，扩容代价低。只需要扩容存放指针的数组 2.头插头删，尾插尾删效率高 3.支持随机访问（效率没有vector高）	1.buffer固定大小，中间插入删除困难，随机访问较易（一般情况是固定大小） 2.buffer不固定大小，中间插入删除较易，随机访问困难 3.优势不像vector与list突出 4.不适合遍历，需要频繁检验是否到达buffer边界

template < class T, class Alloc = allocator<T> > class deque;

二、deque接口

1.容量操作：

函数名称	功能说明
empty	检测deque是否为空，是返回true，否则返回false
size	返回数组大小

2.访问与遍历：

函数名称	功能说明
begin+end	返回第一个元素的迭代器+返回最后一个元素下一个位置的迭代器
rbegin+rend	返回第一个元素的reverse_iterator，即end位置。返回最后一个元素下一个位置的reverse_iterator，即begin位置
front	返回deque的第一个元素的引用
back	返回deque的最后一个元素的引用

3.修改操作：

函数名称	接口说明
push_front	在deque首元素钱插入值为val的元素
pop_front	删除deque中的第一个元素
push_back	在deque尾部插入值为val的元素
pop_back	删除deque最后一个元素
insert	在deque position位置中插入值为val的元素
erase	删除deque position位置的元素
swap	交换两个deque中的元素
clear	清空deque中的有效元素

STL库中deque实现stack与queue

#include<deque>
#include <list>
namespace my_stl
{
	template<class T, class Con = std::deque<T>>
	//template<class T, class Con = list<T>>
	class queue
	{
	public:
		queue() {}
		void push(const T& x) { _c.push_back(x); }
		void pop() { _c.pop_front(); }
		T& back() { return _c.back(); }
		const T& back()const { return _c.back(); }
		T& front() { return _c.front(); }
		const T& front()const { return _c.front(); }
		size_t size()const { return _c.size(); }
		bool empty()const { return _c.empty(); }
	private:
		Con _c;
	};


	template<class T, class Con = std::deque<T>>
	//template<class T, class Con = vector<T>>
	//template<class T, class Con = list<T>>
	class stack
	{
	public:
		stack() {}
		void push(const T& x) { _c.push_back(x); }
		void pop() { _c.pop_back(); }
		T& top() { return _c.back(); }
		const T& top()const { return _c.back(); }
		size_t size()const { return _c.size(); }
		bool empty()const { return _c.empty(); }
	private:
		Con _c;
	};
}