stack模拟实现

用模版实现链式栈和顺序栈

对于stack 的实现，有两种方式，一种是连续空间存储的顺序栈，一种是不连续空间存储的链式栈，在C当中如果要使用两种不同的栈的话，实现方式是不一样的，他们的底层逻辑是不一样的。所以要用不同的方式去实现。

而在C++当中有模版，而且C++当中的 stack 和 queue 不是单独实现的，是复用了 deque 这个类，也就意味着，在同一类当中，可以用模版参数来实现不同的栈。如下所示：

namespace My_stack
{
	template<class T, class Container>
	class stack
	{
	public:

	private:
		Container _con;
	};
}

由上述代码，我们就可以在外面自定义这个栈是链式结构还是顺序结构，如下代码所示：

	My_stack::stack<int, vector<int>> st1;
	My_stack::stack<int, list<int>> st2;

我们这里的顺序栈使用的不是 deque 容器，而是vector，其实deque更好，这样只是简单实现，所以用vector 就足够。

上述就是使用上述 stack 模版的方式，这样，我们就可以自定义 stack 的存储类型，和存储结构了。

直接复用有一个好处，我们可以不用实现构造函数和析构函数，因为我们使用的空间不是我们是实现的 stack 类监管，而是由 vector 和 list 监管。

在官方文档中，我们发现这里的 Container 模版参数给了缺省值，其实模版参数也是有缺省值的，这里的缺省值给的是类型。如下所示：

所以我，还可以进行优化：

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

增删查改

因为stack 是 vector 和 list 容器来实现，所以下面的函数也都可以复用两个容器当中函数。

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

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

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

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

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

总代码

#pragma once

namespace My_stack
{
	template<class T, class Container = vector<T>>
	class stack
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

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

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

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

		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
}

queue 模拟实现

队列的实现和栈是一样的，都可以是使用其他类的复用，达到容器适配器的效果：

#pragma once
#include<vector>
#include<list>
#include<deque>

namespace bit
{
	// 
	template<class T, class Container = deque<T>>
	class queue
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_front();
			//_con.erase(_con.begin());
		}

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

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

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

		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};

	void test_queue()
	{
		 queue<int, list<int>> q;

		//queue<int, vector<int>> q;
		q.push(1);
		q.push(2);
		q.push(3);
		q.push(4);

		while (!q.empty())
		{
			cout << q.front() << " ";
			q.pop();
		}
		cout << endl;
	}
}

注意：虽然我们上述实现的了 queue的 vector底层结构实现，但是queue用 vector 不太好，因为缺如是先进先出的结构，这里vector 找尾需要遍历，存在效率问题，而且头删存储移位问题，效率不好。

在库当中的 queue 就没有支持 vector 为底层结构的 queue，因为在库当中，queue的Pop函数是直接调用的 pop_front() 这个函数，而这个函数是 vector没有的：

deque

deque的优劣

我们前面多次提到了 deque 这个容器，deque 也叫做 双端队列，虽然叫做队列，但是实际上这个容器已经不是队列了，队列要求是要先进先出，但是deque当中实现了其他功能，如下所示：

我们发现，deque实现了 vector 有 list 没有的 operator[] 函数，还实现了 vector 没有 list 有的头插头删等等。可以说，deque的功能是 vector 和 list 的结合体。

虽然功能上很齐全，但是单个功能的效率不如 vector 和 list。

下述测试 deque 直接 sort（）快排，和 deque 拷贝数据到 vector 之后排序，在拷贝回去，这两种方式的时间消耗（10000000个数据）：

void test_op()
{
	srand(time(0));
	const int N = 1000000;
	vector<int> v1;
	vector<int> v2;
	v1.reserve(N);
	v2.reserve(N);

	deque<int> dq1;
	deque<int> dq2;


	for (int i = 0; i < N; ++i)
	{
		auto e = rand();
		//v1.push_back(e);
		//v2.push_back(e);
		dq1.push_back(e);
		dq2.push_back(e);
	}

	// 拷贝到vector排序，排完以后再拷贝回来
	int begin1 = clock();
	// 先拷贝到vector
	for (auto e : dq1)
	{
		v1.push_back(e);
	}

	// 排序
	sort(v1.begin(), v1.end());

	// 拷贝回去
	size_t i = 0;
	for (auto& e : dq1)
	{
		e = v1[i++];
	}

	int end1 = clock();

	int begin2 = clock();
	//sort(v2.begin(), v2.end());
	sort(dq2.begin(), dq2.end());

	int end2 = clock();

	printf("deque copy vector sort:%d\n", end1 - begin1);
	printf("deque sort:%d\n", end2 - begin2);
}

输出：

发现 deque 效率更低，但是deque的拷贝消耗不大，几乎可以省略。

deque的底层实现

之前的vector 容器，扩容的时候都是有代价的，比如 vector 容器，它的扩容就是新开辟一个空间，然后把原空间当中的数据拷贝到新的空间当中。这样做的代价不小，所以deque就在list 和 vector 之间做了新的结构设计：

deque底层设计：

如上图所示，是deque的结构设计，它有一个中控（指针数组）来维护多个顺序表（连续存储结构）。而且存储各个顺序表的头指针的中控（指针数组）并不是从开始来存储指针，而是从中间开始存储，这样方便头插和尾差的时候，往前或后新开辟空间，用新指针来维护新开皮带空间。
每一个顺序表的size（），元素个数是一样的。
如果像头插和尾插数据，这种操作，可以新开辟一块空间，用新的指针来维护，在中控（指针数组当中指针是有顺序的）。
如果中控（指针数组）存储的指针满了，可以对中控（指针数组）单独扩容。
上述提到了中控（指针数组）可以单独扩容，这样的好处是：扩容时候，不需要拷贝其他顺序表当中的数据，主需要拷贝自己的指针数据，或者是存储在这单个的顺序表当中数据即可，大大减少了靠北的消耗。

这么一说，上述 deque 的结构，跟 vector<vector<T>> 这个结构差异还是很大的，vector<vectorT>> 当中的 “指针数组 ” 存储的是一个一个的对象，而每一个对象当中都有一个数组。

deque当中的头插和尾插顺序：

问题：那么中间插入是不是，不需要后面挪动数据，直接在想插入的位置的顺序表空间当中直接插入，需要挪动的只是这个小的顺序表中后面的数据，如果满了，只用扩容这个一个小的顺序表空间。

其实不是，可以看下面 vector 当中的对比和 operator[] 的实现方式。

迭代器

deque的底层实现是非常复杂的，处了上述的基本结构和功能，deque的迭代器的实现也是很复杂，deque的迭代器的封装了四个指针：

first 和 last 分别指向每一段数组的开始和结束位置。
cur 指向在这个数组中，当前数据的位置。
node 是一个二级指针，反向过来指向中控器，这样利于寻找下一个数组。

迭代器遍历过程如下图：

*it ：解引用 it，解引用的是 cur，由cur 来遍历数组。
++it：有两种情况，一种是没有走到 last ，此时说明当前数组还没有走完，那么就直接 ++cut；如果当前数组走完了，就 ++node ，这样 node 就指向了下一个数组。更新其他是哪个指针的指向下一个位置的指定位置。

库当中是这样实现的：

deque 和 vector 相比

相比于 vector， deque 很大程度上的解决了扩容的问题（头插头删，中间插/删）。但是在 operator[] 这个函数的实现比较复杂，这个函数需要计算，这个下标在哪一个顺序表当中，计算方式如下：

首先看是否在第一个顺序表当中，在就找位置访问；
不在第一个数组，用 i - 第一个数组的 size（），再去取 / 计算在第几个数组当中，在取 % 计算在这个数组的那一个位置。

虽然看上去计算并不多，但是在大量访问的时候还是有很大的效率问题，这里就印证了为什么上述deque 的sort() 跑不过 vector 的sort（），因为在sort（）当中用了很多的 operator[] 函数。

deque 和 list 相比

好处：

首先是支持 operator[] 函数。
cpu高速缓存当中效率不错。

缺点：

头尾插删，都差不多，但是在中间插入和删除不好。这里没有使用上述在 deque 的底层实现小结当中最后提出的问题一样，没有使用那样的方式来实现，因为如果每一个顺序表的大小都是相等的，那么 operator[] 函数在计算下标位置的时候更加方便快捷。如果每一个顺序表的大小不一样，只能使用遍历的方式来计算个数，这样很麻烦。

所以，deque采用但是挪动数据来实现的中间插入和删除。那么挪动数据所带来的代价就很大了。