C++——模拟实现stack和queue

1.传统模拟方式

cpp 复制代码

namespace jxy
{
	template<class T>
	class stack
	{
    //...
	private:
		T* _a;
		size_t _size;
		size_t _capacity;
	};
}

2.适配器方式模拟

cpp 复制代码

namespace jxy
{

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

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

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

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

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

	private:
		Container _con;
	};
}

cpp 复制代码

这种方式叫做适配器方式
所以栈是容器适配器，它可以去适配
传顺序表数组，可以使用顺序表适配出需要的栈
传链表，也可以适配出需要的栈
它可以通过模板参数来控制底层容器是什么
不管这个底层容器是什么，都可以适配出后进先出的栈
template<class T,class Container>
class stack
{
    //...

private:
	Container _con;
};

//使用时
jxy::stack<int, vector<int>> st;
jxy::stack<int, list<int>> st;

3.deque

deque：双端队列 ，一种容器

注意：它不是队列，不要求先进先出，两端都可以操作，适合在两端进行插入、删除等

那么有没有中间一点的方案、结构，可以把它们的优点融合一下？

答案是有的，deque就是融合了它们的优点。

3.1对比deque和vector的\[\]效率

cpp 复制代码

void test_op()
{
    srand(time(0));
    const int N = 100000;

    deque<int> dq;
    vector<int> v;

    for (int i = 0; i < N; ++i)
    {
        auto e = rand();
        dq.push_back(e);
        v.push_back(e);
    }

    //1.deque的sort
    int begin1 = clock();
    sort(dq.begin(), dq.end());
    int end1 = clock();

    //2.vector的sort
    int begin2 = clock();
    sort(v.begin(), v.end());
    int end2 = clock();

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

    //排序底层会大量访问数据，所以这里其实就是在拿它们的[]进行对比
    //因为算法是一样的，唯一区别就是[]不一样
}

显然vector的 \[\] 效率更高

3.2第二种对比方式

cpp 复制代码

void test_op1()
{
    srand(time(0));
    const int N = 100000;

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

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

    //1.de1的sort
    int begin1 = clock();
    sort(dq1.begin(), dq1.end());
    int end1 = clock();

    //2.dq2的sort
    int begin2 = clock();

    //拷贝到vector
    vector<int> v(dq2.begin(), dq2.end());
    sort(v.begin(), v.end());
    //赋值回去
    dq2.assign(v.begin(), v.end());

    int end2 = clock();

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

哪怕是把deque的数据拷贝给vector去排序，都比自身的效率高，只能说deque是小丑中的小丑。

同时也说明，拷贝的消耗不是很大

3.3总结

实际上，deque并不常用

下标的随机访问，还是vector更强

头、尾的插入删除方面，deque还不错，略优于vector和list

并且相对于list它的CPU高速缓存更好

它 头、尾的插入、删除 效率**> \[\] > 中间位置的插入、删除**

4.模拟实现queue

queue的模拟实现与stack同理

cpp 复制代码

namespace jxy
{

	//注意：队列是队尾插入、队头删除，所以vector不能适配queue
	//如果使用了就会报错
	template<class T, class Container = deque<T>>
	//适配器的特点就是它允许你去更改底层的容器
	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();
		}

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

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

	private:
		Container _con;
	};
};

cpp 复制代码

void test_queue()
{
	jxy::queue<int> q;
	q.push(1);
	q.push(2);
	q.push(3);
	q.push(4);
	q.push(5);

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