初识C++|stack、queue、priority_queue的使用和模拟实现

最新推荐文章于 2024-09-11 15:01:00 发布

mooridy

最新推荐文章于 2024-09-11 15:01:00 发布

阅读量761

点赞数 24

文章标签：数据结构 c++

本文链接：https://blog.csdn.net/mooridy/article/details/141467415

版权

🍬 mooridy-CSDN博客

🧁C++专栏（更新中！）

stack

使用

函数说明	接口说明
stack()	构造空的栈
empty()	检测stack是否为空
size()	返回stack中元素的个数
top()	返回栈顶元素的引用
push()	将元素val压入stack中
pop()	将stack中尾部的元素弹出

底层实现

从栈的接口中可以看出，栈实际是一种特殊的 vector ，因此使用 vector 完全可以模拟实现 stack 。

#include<vector>
namespace A
{
template<class 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:
std::vector<T> _c;
};
}

但其实它的底层是由deque实现的（deque讲解见下文）

//stack.h
#pragma once
#include<deque>

namespace A
{

    template<class T, class Con = deque<T>>
    class stack
    {

    public:

        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;
    };
};

queue

使用

函数声明	接口说明
queue()	构造空的队列
empty()	检测队列是否为空，是返回true，否则返回false
size()	返回队列中有效元素的个数
front()	返回队头元素的引用
back()	返回队尾元素的引用
push()	在队尾将元素val入队列
pop()	将队头元素出队列

底层实现

因为 queue 的接口中存在头删和尾插，因此使用 vector 来封装效率太低，故可以借助 list 来模拟实

现 queue ，具体如下：

#include <list>
namespace A
{
template<class 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:
std::list<T> _c;
};
}

但其实它的底层是由deque实现的（deque讲解见下文）

#pragma once
#include<deque>
namespace A
{


    template<class T, class Con = deque<T>>
    class queue

    {

    public:
        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;

    };

};

适配器模式

什么是适配器

适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设

计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。

STL标准库中stack和queue的底层结构

虽然 stack 和 queue 中也可以存放元素，但在 STL 中并没有将其划分在容器的行列，而是将其称为

容器适配器 ，这是因为 stack 和队列只是对其他容器的接口进行了包装， STL 中 stack 和 queue 默认

使用 deque ，比如：

deque

deque的简单介绍

deque( 双端队列 ) ：是一种双开口的 " 连续 " 空间的数据结构 ，双开口的含义是：可以在头尾两端

进行插入和删除操作，且时间复杂度为 O(1) ，与 vector 比较，头插效率高，不需要搬移元素；与

list 比较，空间利用率比较高。

结论：vector和list的缝合怪，支持随机访问，头插头删

deque的原理和底层介绍

deque 并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际 deque 类似于一个

动态的二维数组。

双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其 “ 整体连续 ” 以及随机访问

的假象，落在了 deque 的迭代器身上， 因此 deque 的迭代器设计就比较复杂，如下图所示：

deque的缺陷

与 vector 比较， deque 的优势是：头部插入和删除时， 不需要搬移元素，效率特别高 ，而且在扩

容时，也不需要搬移大量的元素 ，因此其效率是必 vector 高的。

与 list 比较，其底层是连续空间， 空间利用率比较高 ，不需要存储额外字段。

但是， deque 有一个致命缺陷：不适合遍历，因为在遍历时， deque 的迭代器要频繁的去检测其

是否移动到某段小空间的边界，导致效率低下 ，而序列式场景中，可能需要经常遍历，因此在实

际中，需要线性结构时，大多数情况下优先考虑 vector 和 list ， deque 的应用并不多，而 目前能看

到的一个应用就是， STL 用其作为 stack 和 queue 的底层数据结构 。

为什么选择deque作为stack和queue的底层默认容器

stack 是一种后进先出的特殊线性数据结构，因此只要具有 push_back() 和 pop_back() 操作的线性

结构，都可以作为 stack 的底层容器，比如 vector 和 list 都可以； queue 是先进先出的特殊线性数据

结构，只要具有 push_back 和 pop_front 操作的线性结构，都可以作为 queue 的底层容器，比如

list 。但是 STL 中对 stack 和 queue 默认选择 deque 作为其底层容器，主要是因为：

1. stack 和 queue 不需要遍历 ( 因此 stack 和 queue 没有迭代器 ) ，只需要在固定的一端或者两端进

行操作。

2. 在 stack 中元素增长时， deque 比 vector 的效率高 ( 扩容时不需要搬移大量数据 ) ； queue 中的

元素增长时， deque 不仅效率高，而且内存使用率高。

结合了 deque 的优点，而完美的避开了其缺陷。

priority_queue

使用

优先级队列默认使用 vector 作为其底层存储数据的容器，在 vector 上又使用了堆算法将 vector 中

元素构造成堆的结构，因此 priority_queue 就是堆，所有需要用到堆的位置，都可以考虑使用

priority_queue 。注意：默认情况下 priority_queue 是大堆 。

函数声明	接口说明
priority_queue()/priority_queue(first, last)	构造一个空的优先级队列
empty( )	检测优先级队列是否为空，是返回 true ，否则返回 false
top( )	返回优先级队列中最大 ( 最小元素 ) ，即堆顶元素
push(x)	在优先级队列中插入元素x
pop()	删除优先级队列中最大 ( 最小 ) 元素，即堆顶元素

仿函数

priority_queue 需要一个仿函数来确定元素的优先级顺序。默认情况下，priority_queue 使用 less<T> 作为比较准则，即优先队列后面的元素都要小于优先队列前面的元素，因为优先队列队首的元素优先级最高，优先队列队尾元素的优先级最低，所以小于号<就规定了优先队列后面的元素都要小于优先队列前面的元素（尾部优先级小于首部优先级），也就是形成一个大根堆，降序排序，每次权值最大的会被弹出来。

而通过定义自己的仿函数，用户可以指定 priority_queue 中元素如何相互比较。

priority_queue<int, vector<int>, greater<int>> pq2; //小根堆，升序

在C++中，仿函数是实现了operator()的类的对象，使得它们可以被像函数一样调用。这实际上是一种重载了()操作符的类，使得其对象能够表现得像函数一样。

仿函数为C++的泛型编程和STL中的算法和容器提供了强大的灵活性。

定义仿函数

仿函数是通过定义一个类并在其中重载()操作符来实现的。这个操作符可以接受任意数量和类型的参数（根据需求），并可以返回一个值。

#include <iostream>  
  
// 定义仿函数  
class Add {  
public:  
    // 重载()操作符  
    int operator()(int a, int b) const {  
        return a + b;  
    }  
};  
  
int main() {  
    Add add; // 创建仿函数对象  
    int result = add(5, 3); // 像函数一样调用仿函数对象  
    std::cout << "The sum is: " << result << std::endl;  
    return 0;  
}

何时使用仿函数

1.类类型不支持比较大小

2.支持比较大小，但是比较的逻辑不是你想要的（例子，date类）

下面的底层实现就运用到了仿函数。

底层实现


#include<vector>
#include<functional>



namespace A

{
    template<class T>
    class less {
    public:
        bool operator()(const T& x, const T& y) {
            return x < y;
        }
    };

    template<class T>
    class greater {
    public:
        bool operator()(const T& x, const T& y) {
            return x > y;
        }
    };


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

    class priority_queue

    {

    public:
      

       // template <class InputIterator>

       // priority_queue(InputIterator first, InputIterator last);

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

        void adjustdown(int parent) {
            Compare comp;
            int child = parent * 2 + 1;
            while (child<c.size()) {
                if (child+1<c.size()&&comp(c[child] , c[child + 1])) {
                    child ++;
                }
                if (comp(c[parent], c[child])) {
                    swap(c[parent], c[child]);
                    parent=child;
                    child = parent * 2 + 1;
                }
                else {
                    break;
                }
            }
        }


        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(size()-1);

        }

        void pop() {
            swap(c[0], c[size() - 1]);
            c.pop_back();
            adjustdown(0);
        }


    private:

        Container c;


    };

};

算法库中关于堆的算法

sort_heap

用途：进行堆排序

使用注意：函数使用对象必须为堆

is_heap

判断是否为堆

make_heap

建堆算法

push_heap&&pop_heap

push_heap 函数的作用是将位于 [first, last-1) 范围内的元素视为一个堆，并将 *(last-1)（即最后一个元素）添加到这个堆中，同时重新排列元素以保持堆的性质。

相当于adjustup函数

而pop_heap函数，则相当于adjustdown函数

#include <iostream>     
#include <algorithm>    
#include <vector>       
int main () {
  int myints[] = {10,20,30,5,15};
  std::vector<int> v(myints,myints+5);

  std::make_heap (v.begin(),v.end());
  std::cout << "initial max heap   : " << v.front() << '\n';

  std::pop_heap (v.begin(),v.end()); v.pop_back();
  std::cout << "max heap after pop : " << v.front() << '\n';

  v.push_back(99); std::push_heap (v.begin(),v.end());
  std::cout << "max heap after push: " << v.front() << '\n';

  std::sort_heap (v.begin(),v.end());

  std::cout << "final sorted range :";
  for (unsigned i=0; i<v.size(); i++)
    std::cout << ' ' << v[i];

  std::cout << '\n';

  return 0;