C++入门篇10---stack+queue+priority_queue

竹下为生

已于 2023-09-27 22:24:26 修改

阅读量119

点赞数

分类专栏： C++ 文章标签： c++ 开发语言

于 2023-09-27 22:16:25 首次发布

本文链接：https://blog.csdn.net/V_zjs/article/details/133363342

版权

C++ 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

前言

本文主要是介绍C++库中的栈、队列和优先级队列(其实就是堆)的一些接口以及如何用C++来实现它们，对这三种数据结构就不多介绍了，如有不了解的同学，请查阅我之前写的两篇博客

栈和队列的实现
二叉树和堆详解

下面正片开始

一、stack

1.了解stack的相关接口

函数名称	接口说明
empty()	查看栈是否为空
size()	查看栈中的元素个数
push()	将元素压入栈中
pop()	从栈顶删除元素
top()	返回栈顶元素
stack()	构造空栈

void test1()
{
	//后进先出
	stack<int>st;
	st.push(1);
	st.push(3);
	st.push(4);
	st.push(2);
	while (st.size())
	{
		cout << st.top() << endl;
		st.pop();
	}
}

2.stack的实现

//这里统一说明一下，栈、队列、优先级队列都是适配器容器，不是容器
//所谓的适配器容器就是对其他容器的接口进行包装，改造实现的
//我们往下看就会发现，stack的实现基本上都是在调用其他容器的函数
//其实我们在学数据结构的时候，就已经发现栈既可以用数组实现，也能用链表实现
//本质就是因为数组和链表两种数据结构的功能都符合stack的需求，这里也是一样
//stack不关心它用的什么容器实现，它只关心该容器是否有它需要的功能函数
//同时这里也体现了C++库的发明人的智慧，所有容器的功能相同的函数名称基本都一样(可谓妙绝，请细品)
namespace zxws {
    //deque是双端队列---该容器的底层实现以后有机会再讲，各位可以去看一眼deque的文档，
    //它也支持下面的几个函数，同时它的底层实现和stack最搭配，所以库里的stack默认用它实现
	template<class T, class Container = deque<T>>
	class Stack {
	private:
		Container _con;
	public:
		T& top() {
			return _con.back();
		}
		const T& top() const{
			return _con.back();
		}
		void pop() {
			_con.pop_back();
		}
		void push(const T& val) {
			_con.push_back(val);
		}
		size_t size() const{
			return _con.size();
		}
		bool empty() {
			return _con.empty();
		}
	};
}

二、queue

1.了解queue的相关接口

函数声明	接口说明
empty()	判断队列是否为空
size()	查看队列中的元素个数
push()	向队列中插入元素
pop()	从队头删除元素
front()	返回队头元素
back()	返回队尾元素
queue()	构造空队列

void test2()
{
	queue<int>q;
	q.push(1);
	q.push(3);
	q.push(4);
	q.push(2);
	while (q.size())
	{
		cout << q.front() << endl;
		q.pop();
	}
}

2.queue的实现

namespace zxws {
	template<class T,class Container = deque<T>>
    //deque的底层实现和queue最搭配，所以库里的queue默认用它实现
    //当然这并不是说deque就比vector、list更好，只是各有各的适用场景
	class Queue {
	private:
		Container _con;
	public:
		T& front() {
			return _con.front();
		}
		T& back() {
			return _con.back();
		}
		const T& front() const {
			return _con.front();
		}
		const T& back() const {
			return _con.back();
		}
		void pop() {
			_con.pop_front();
		}
		void push(const T& val) {
			_con.push_back(val);
		}
		size_t size() {
			return _con.size();
		}
		bool empty() {
			return _con.empty();
		}
	};
}

三、priority_queue(优先级队列)---堆(heap)

1.了解priority_queue的相关接口

函数声明	接口说明
priority_queue()/priority_queue(first,last)	构造一个空的优先级队列/用一段迭代器区间初始化
empty()	查看优先级队列是否为空
size()	返回优先级队列中的元素个数
push()	向优先级队列中插入元素
top()	返回优先级队列中的最大/最小元素，即堆顶元素
pop()	删除优先级队列中的最大/最小元素，即堆顶元素

void test3()
{
	priority_queue<int>q;//默认大堆
	//priority_queue<int, vector<int>, greater<int>>q;//小堆
	//这里后面的实现中会讲到
	q.push(1);
	q.push(3);
	q.push(4);
	q.push(2);
	while (q.size())
	{
		cout << q.top() << endl;
		q.pop();
	}
}

2.priority_queue的实现

namespace zxws
{
    template <class T, class Container = vector<T>, class Compare = less<T> >
    class priority_queue
    {
    public:

        priority_queue(){}
        void AdjustDown(int parent) 
        {
            int n = c.size();
            for (int child = parent * 2 + 1; child < n; parent = child, child = parent * 2 + 1)
            {
                if (child + 1 < n && comp(c[child],c[child+1]))
                    child++;
                if (comp(c[parent], c[child]))
                    swap(c[parent], c[child]);
                else
                    break;
            }
        }

        void AdjustUp(int child)
        {
            for (int parent = (child - 1) / 2; child > 0; child = parent, parent = (child - 1) / 2)
            {
                if (comp(c[parent], c[child]))
                    swap(c[parent], c[child]);
                else
                    break;
            }
        }

        template <class InputIterator>
        priority_queue(InputIterator first, InputIterator last)
            :c(first,last)
        {
            for (int i = (c.size() - 1 - 1) / 2; i >= 0; i--)
                AdjustDown(i);
        }

        bool empty() const
        {
            return c.empty();
        }

        size_t size() const
        {
            return c.size();
        }

        const T& top() const
        {
            return c[0];
        }

        void push(const T& x)
        {
            c.push_back(x);
            AdjustUp(c.size() - 1);
        }

        void pop()
        {
            swap(c.back(), c[0]);
            c.pop_back();
            AdjustDown(0);
        }

    private:
        Container c;
        Compare comp;
    };
};

(上面priority_queue的实现的第三个模板参数其实是仿函数，有兴趣的可以去查查什么是仿函数)

四、补充---简单说明一下deque

deque(双端队列)：是一种双开口的"连续"空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高

双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落在了deque的迭代器身上，给张图，让大家简单了解一下

deque的优缺点

与vector比较，deque的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率是必vector高的。
与list比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。
但是，deque有一个致命缺陷：不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构

思考：大家可以结合deque的优点想想为什么stack和queue底层的默认容器是deque？