栈是一种特殊的线性表，只允许在固定的一端进行插入和删除元素的操作。

进行数据插入的删除和操作的一端，称为栈顶。另一端则称为栈底。

stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为

栈中进入数据称为 — 入栈 push

栈中弹出数据称为 — 出栈 pop

文档介绍：stack - C++ Reference

stack 是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。

stack 是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。

标准容器 vector、deque、list 均符合这些需求，默认情况下，如果没有为 stack 指定特定的底层容器，默认情况下使用 deque。

stack 常用接口

功能描述：栈容器常用的对外接口

构造函数：

stack<T> stk; //stack采用模板类实现， stack对象的默认构造形式

stack(const stack &stk); //拷贝构造函数

赋值操作：

stack& operator=(const stack &stk); //重载等号操作符

数据存取：

push(elem); //向栈顶添加元素

pop(); //从栈顶移除第一个元素

top(); //返回栈顶元素

大小操作：

empty(); //判断堆栈是否为空

size(); //返回栈的大小

示例：

#include<iostream>
#include<string> 
using namespace std;
#include <stack>

//栈容器常用接口
void test01()
{
	//创建栈容器 栈容器必须符合先进后出
	stack<int> s;

	//向栈中添加元素，叫做 压栈 入栈
	s.push(10);
	s.push(20);
	s.push(30);

	while (!s.empty()) {
		//输出栈顶元素
		cout << "栈顶元素为： " << s.top() << endl;
		//弹出栈顶元素
		s.pop();
	}
	cout << "栈的大小为：" << s.size() << endl;

}

int main() {

	test01();

	system("pause");

	return 0;
}

输出：

栈顶元素为： 30
栈顶元素为： 20
栈顶元素为： 10
栈的大小为：0

模拟实现stack类

函数接口

  #include<deque>

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

  class stack

  {

  public:

    stack();

    void push(const T& x);

    void pop();

    T& top();

    const T& top()const;

    size_t size()const;

    bool empty()const;

  private:

    Con _c;

  };

模拟实现

/*

*思路：

* 1. stack和queue的模拟实现思路一样，都是通过容器适配而成

* 2. 容器的模板参数Con给出容器deque作为底层的默认容器(使用的过程中也可以自己指定容器)

* 3. stack和queue的方式实现在底层都是转为调用适配容器，只要容器能够满足所有的转调用操作，都可以充当适配   容器

* 4. 由于stack和queue是通过其他容器适配而成，所以stack和queue称为容器适配器

*/
#include<deque>

  template<class T, class Con = deque<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;

  };

queue 容器

queue 基本概念

概念：Queue是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口

队列容器允许从一端新增元素，从另一端移除元素

队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为

队列中进数据称为 — 入队 push

队列中出数据称为 — 出队 pop

文档介绍：queue - C++ Reference

队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。

队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue 提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。

标准容器类 deque 和 list 满足了这些要求。默认情况下，如果没有为 queue 实例化指定容器类，则使用标准容器 deque。

queue 常用接口

功能描述：栈容器常用的对外接口

构造函数：

queue<T> que; //queue采用模板类实现，queue对象的默认构造形式

queue(const queue &que); //拷贝构造函数

赋值操作：

queue& operator=(const queue &que); //重载等号操作符

数据存取：

push(elem); //往队尾添加元素

pop(); //从队头移除第一个元素

back(); //返回最后一个元素

front(); //返回第一个元素

大小操作：

empty(); //判断堆栈是否为空

size(); //返回栈的大小

#include<iostream>
#include<string> 
using namespace std;
#include <stack>
#include <queue>

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	string m_Name;
	int m_Age;
};

void test01() {

	//创建队列
	queue<Person> q;

	//准备数据
	Person p1("唐僧", 30);
	Person p2("孙悟空", 1000);
	Person p3("猪八戒", 900);
	Person p4("沙僧", 800);

	//向队列中添加元素  入队操作
	q.push(p1);
	q.push(p2);
	q.push(p3);
	q.push(p4);

	//队列不提供迭代器，更不支持随机访问	
	while (!q.empty()) {
		//输出队头元素
		cout << "队头元素-- 姓名： " << q.front().m_Name 
              << " 年龄： "<< q.front().m_Age << endl;
        
		cout << "队尾元素-- 姓名： " << q.back().m_Name  
              << " 年龄： " << q.back().m_Age << endl;
        
		cout << endl;
		//弹出队头元素
		q.pop();
	}

	cout << "队列大小为：" << q.size() << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

输出：

队头元素-- 姓名：唐僧年龄： 30
队尾元素-- 姓名：沙僧年龄： 800

队头元素-- 姓名：孙悟空年龄： 1000
队尾元素-- 姓名：沙僧年龄： 800

队头元素-- 姓名：猪八戒年龄： 900
队尾元素-- 姓名：沙僧年龄： 800

队头元素-- 姓名：沙僧年龄： 800
队尾元素-- 姓名：沙僧年龄： 800

队列大小为：0

模拟实现queue类

函数接口

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

  class queue

  {

  public:

    queue();

    void push(const T& x);

    void pop();

    T& back();

    const T& back()const;

    T& front();

    const T& front()const;

    size_t size()const;

    bool empty()const;

  private:

    Con _c;

  };

模拟实现

/*

*思路：

* 1. stack和queue的模拟实现思路一样，都是通过容器适配而成

* 2. 容器的模板参数Con给出容器deque作为底层的默认容器(使用的过程中也可以自己指定容器)

* 3. stack和queue的方式实现在底层都是转为调用适配容器，只要容器能够满足所有的转调用操作，都可以充当适配   容器

* 4. 由于stack和queue是通过其他容器适配而成，所以stack和queue称为容器适配器

*/
#include<deque>
template<class T, class Con = deque<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;

  };

优先级队列 - priority queue

priority_queue 的概念

优先级队列（priority_queue）其实，不满足先进先出的条件，更像是数据类型中的“堆”。优先级队列每次出队的元素是队列中优先级最高的那个元素，而不是队首的元素。这个优先级可以通过元素的大小等进行定义。比如定义元素越大优先级越高，那么每次出队，都是将当前队列中最大的那个元素出队

文档介绍：priority_queue - C++ Reference

优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。

此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素（优先队列中位于顶部的元素）。

优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。

标准容器类 vector 和 deque 满足这些需求。默认情况下，如果没有为特定的 priority_queue 类实例化指定容器类，则使用 vector。

需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数 make_heap、push_heap 和 pop_heap 来自动完成此操作。

优先级队列的使用

优先级队列默认使用 vector 作为其底层存储数据的容器，

在 vector 上又使用了堆算法将 vector 中元素构造成堆的结构，因为 priority_queue 就是堆。

所有需要用到堆的地方，都可以考虑使用 priority_queue。

值得注意的是，priority_queue 默认为大根堆。

优先级队列默认大的优先级高，传的是 less 仿函数，底层是一个大堆；

如果想控制小的优先级高，需手动传 greater 仿函数，其底层是一个小堆。

empty()：检测容器是否为空

size()：返回容器中有效元素个数

front()：返回容器中第一个元素的引用

push_back()：在容器尾部插入元素

pop_back()：删除容器尾部元素

#include <iostream>
#include <queue>
#include <functional>  // greater算法的头文件
using namespace std;

void test_priority_queue() 
{
    priority_queue<int, vector<int>, greater<int> > pQ;
  
    pQ.push(2);
    pQ.push(5);
    pQ.push(1);
    pQ.push(6);
    pQ.push(8);
    while (!pQ.empty()) {
        cout << pQ.top() << " ";
        pQ.pop();
    }
    cout << endl;


    priority_queue<int> pQ2;
 //默认是用 vector 存储的，注意这里没有明确指定 less 还是 greater，所以默认为 less。
    pQ2.push(2);
    pQ2.push(5);
    pQ2.push(1);
    pQ2.push(6);
    pQ2.push(8);
    while (!pQ2.empty()) {
        cout << pQ2.top() << " ";
        pQ2.pop();
    }
    cout << endl;
}



int main() {
    test_priority_queue();
    return 0;
}

输出：

1 2 5 6 8
8 6 5 2 1

默认是用 vector 存储的，注意这里没有明确指定 less 还是 greater，所以默认为 less。

我们在定义优先级队列时主动去传 greater<int> 即可令该优先级队列以小的优先级高。

模拟实现priority_queue类

函数接口

namespace bit

{

  #include<vector>

  #include<functional>

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

  class priority_queue

  {

  public:

    priority_queue();

    template <class InputIterator>

    priority_queue(InputIterator first, InputIterator last);

    bool empty() const;

    size_t size() const;

    T& top() const;

    void push(const T& x);

    void pop();

  private:

    Container c;

    Compare comp;

  };

};

模拟实现

namespace bit

{

  //函数对象 less
  template<class T>

  struct less
  {
    bool operator()(const T& left, const T& right)
    { 
      return left < right; 
    }
  };

  //函数对象 greater
  template<class T>

  struct greater
  {
    bool operator()(const T& left, const T& right)
    { 
      return left > right; 
    }
  };
   

namespace bit
{

  //函数对象 less
  template<class T>
  struct less
  {
    bool operator()(const T& left, const T& right)
    { 
      return left < right; 
    }
  };


  //函数对象 greater
  template<class T>
  struct greater
  {
    bool operator()(const T& left, const T& right)
    { 
      return left > right; 
    }
  };

   

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

    //创建空的优先级队列
    priority_queue():c()
    {}

    template <class InputIterator>
    priority_queue(InputIterator first, InputIterator last)
      :c(first, last)
    {
      //将c中的元素调整为堆的结构，默认为大堆
      int count = c.size();
      int root = ((count - 2) >> 1);
      for (; root >= 0; root--)
       AdjustDown(root);
    }

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

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

    // 堆顶元素不允许修改，因为：堆顶元素修改可以会破坏堆的特性

    const T& top() const
    {
      return c.front();
    }

    void push(const T& x)
    {
      c.push_back(x);
      //push_heap(c.begin(), c.end(), comp);
      AdjustUp(c.size() - 1);
    }

    void pop()
    {
      if (empty())
       return;
      std:swap(c.front(), c.back());
      c.pop_back();
      AdjustDown(0);
    }

  private:

    //向上调整

    void AdjustUp(int child)
    {

      int parent = ((child - 1) >> 1);
      while (child)
      {
        if (Com(c[parent], c[child]))
        {
          std::swap(c[child], c[parent]);
          child = parent;
          parent = ((child - 1) >> 1);
       }
        else  return;

      }

    }

     

    //向下调整
    void AdjustDown(int parent)
    {
      int child = parent * 2 + 1;
      while (child < c.size())
      {

        // 找以parent为根的较大的孩子
        if (child + 1 < c.size() && Com(c[child], c[child+1]))
        child += 1;

        // 检测双亲是否满足情况
        if (Com(c[parent], c[child]))
        {
          std::swap(c[child], c[parent]);
          parent = child;
          child = parent * 2 + 1;
       }
       else  return;

      }

    }

  private:

    Container c;

Compare Com;
  };

};

双端队列 - double ended queue

deque容器基本概念

功能：

双端数组，可以对头端进行插入删除操作

deque与vector区别：

deque 可以在头尾两端进行插入和删除操作，且时间复杂度为 $O(1)$ ，比vector快,

vector访问元素时的速度会比deque快,这和两者内部实现有关

deque内部工作原理:

deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据

中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间

deque容器的迭代器也是支持随机访问的

deque构造函数

deque<T> deqT; //默认构造形式
deque(beg, end); //构造函数将[beg, end)区间中的元素拷贝给本身。
deque(n, elem); //构造函数将n个elem拷贝给本身。
deque(const deque &deq); //拷贝构造函数

注意：

void printDeque(deque<int>& d) 
{
	for (deque<int>::iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}
无const，迭代器用iterator

void printDeque(const deque<int>& d) 
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}
有const限定用cosnt_iterator

示例：

#include <iostream>

using namespace std;
#include <deque>

void printDeque(const deque<int>& d) 
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}
//deque构造
void test01() {

	deque<int> d1; //无参构造函数
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeque(d1);
	deque<int> d2(d1.begin(),d1.end());
	printDeque(d2);

	deque<int>d3(10,100);
	printDeque(d3);

	deque<int>d4 = d3;
	printDeque(d4);
}

int main() {

	test01();

	system("pause");

	return 0;
}

输出：

0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
100 100 100 100 100 100 100 100 100 100
100 100 100 100 100 100 100 100 100 100

deque容器和vector容器的构造方式几乎一致，灵活使用即可

deque赋值操作

deque& operator=(const deque &deq); //重载等号操作符
assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem); //将n个elem拷贝赋值给本身。

#include <iostream>

using namespace std;
#include <deque>

void printDeque(const deque<int>& d) 
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}
//赋值操作
void test01()
{
	deque<int> d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeque(d1);

	deque<int>d2;
	d2 = d1;
	printDeque(d2);

	deque<int>d3;
	d3.assign(d1.begin(), d1.end());
	printDeque(d3);

	deque<int>d4;
	d4.assign(10, 100);
	printDeque(d4);

}

int main() {

	test01();

	system("pause");

	return 0;
}

输出：

0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
100 100 100 100 100 100 100 100 100 100

deque大小操作

deque.empty(); //判断容器是否为空
deque.size(); //返回容器中元素的个数
deque.resize(num); //重新指定容器的长度为num,若容器变长，则以默认值填充新位置。

//如果容器变短，则末尾超出容器长度的元素被删除。
deque.resize(num, elem); //重新指定容器的长度为num,若容器变长，则以elem值填充新位置。

//如果容器变短，则末尾超出容器长度的元素被删除。
deque没有容量的概念

示例：

#include <iostream>

using namespace std;
#include <deque>

void printDeque(const deque<int>& d) 
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}

//大小操作
void test01()
{
	deque<int> d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeque(d1);

	//判断容器是否为空
	if (d1.empty()) {
		cout << "d1为空!" << endl;
	}
	else {
		cout << "d1不为空!" << endl;
		//统计大小
		cout << "d1的大小为：" << d1.size() << endl;
	}

	//重新指定大小
	d1.resize(15, 1);
	printDeque(d1);

	d1.resize(5);
	printDeque(d1);
}

int main() {

	test01();

	system("pause");

	return 0;
}

输出：

0 1 2 3 4 5 6 7 8 9
d1不为空!
d1的大小为：10
0 1 2 3 4 5 6 7 8 9 1 1 1 1 1
0 1 2 3 4

deque 插入和删除

两端插入操作：

push_back(elem); //在容器尾部添加一个数据
push_front(elem); //在容器头部插入一个数据
pop_back(); //删除容器最后一个数据
pop_front(); //删除容器第一个数据

指定位置操作：

insert(pos,elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置。
insert(pos,n,elem); //在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end); //在pos位置插入[beg,end)区间的数据，无返回值。
clear(); //清空容器的所有数据
erase(beg,end); //删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos); //删除pos位置的数据，返回下一个数据的位置。

示例：

#include <iostream>

using namespace std;
#include <deque>

void printDeque(const deque<int>& d) 
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}
//两端操作
void test01()
{
	deque<int> d;
	//尾插
	d.push_back(10);
	d.push_back(20);
	//头插
	d.push_front(100);
	d.push_front(200);

	printDeque(d);

	//尾删
	d.pop_back();
	//头删
	d.pop_front();
	printDeque(d);
	cout<<endl;
}

//插入
void test02()
{
	deque<int> d;
	d.push_back(10);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);
	printDeque(d);

	d.insert(d.begin(), 1000);
	printDeque(d);

	d.insert(d.begin(), 2,10000);
	printDeque(d);

	deque<int>d2;
	d2.push_back(1);
	d2.push_back(2);
	d2.push_back(3);

	d.insert(d.begin(), d2.begin(), d2.end());
	printDeque(d);
	cout<<endl;

}

//删除
void test03()
{
	deque<int> d;
	d.push_back(10);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);
	printDeque(d);

	d.erase(d.begin());
	printDeque(d);

	//d.erase(d.begin(), d.end());
	d.clear();
	printDeque(d);

}

int main() {

	test01();

	test02();

    test03();
    
	system("pause");

	return 0;
}

输出：

200 100 10 20
100 10

200 100 10 20
1000 200 100 10 20
10000 10000 1000 200 100 10 20
1 2 3 10000 10000 1000 200 100 10 20

200 100 10 20
100 10 20

（空字符串）

deque 数据存取

at(int idx); //返回索引idx所指的数据
operator[]; //返回索引idx所指的数据
front(); //返回容器中第一个数据元素
back(); //返回容器中最后一个数据元素

除了用迭代器获取deque容器中元素，[ ]和at也可以

示例：

#include <iostream>

using namespace std;
#include <deque>

void printDeque(const deque<int>& d) 
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}

//数据存取
void test01()
{

	deque<int> d;
	d.push_back(10);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);

	for (int i = 0; i < d.size(); i++) {
		cout << d[i] << " ";
	}
	cout << endl;


	for (int i = 0; i < d.size(); i++) {
		cout << d.at(i) << " ";
	}
	cout << endl;

	cout << "front:" << d.front() << endl;

	cout << "back:" << d.back() << endl;

}

int main() {

	test01();

	system("pause");

	return 0;
}

输出：

200 100 10 20
200 100 10 20
front:200
back:20

deque 排序

sort(iterator beg, iterator end) //对beg和end区间内元素进行排序

示例：

#include <iostream>

using namespace std;
#include <deque>
#include <algorithm>

void printDeque(const deque<int>& d) 
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}

void test01()
{

	deque<int> d;
	d.push_back(10);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);
	printDeque(d);
	
	sort(d.begin(), d.end());
	printDeque(d);
	
	sort(d.begin(), d.end(),greater<int>());
	printDeque(d);
}

int main() {

	test01();

	system("pause");

	return 0;
}

输出：

200 100 10 20
10 20 100 200
200 100 20 10

deque，stack 和 queue 的底层默认容器

在 stack 和 queue 的实现上，是选择 deque 作为底层默认容器的。

stack 是一种后进先出的特殊线性数据结构，因此只要具有 push_back() 和 pop_back() 操作的线性结构，都可以作为stack 的底层容器，比如 vector 和 list 都可以； queue是先进先出的特殊线性数据结构，只要具有 push_back和pop_front 操作的线性结构，都可以作为 queue 的底层容器，比如 list 。但是 STL 中对 stack 和 queue默认选择 deque 作为其底层容器，主要是因为：

stack 和 queue 不需要遍历（因此 stack 和 queue 没有迭代器），只需要在固定的一端或者两端进行操作。

在 stack 中元素增长时，deque 比 vector 的效率高（扩容时不需要搬移大量数据）；queue 中的元素增长时，deque 不仅效率高，而且内存使用率高。结合了 deque 的优点，而完美的避开了其缺陷。

deque 的缺陷

deque 有一个致命缺陷：不适合遍历，因为在遍历时， deque 的迭代器要频繁的去检测其是否移动到 某段小空间的边界，导致效率低下 ，而序列式场景中，可能需要经常遍历，因此 在实际中，需要线性结构 时，大多数情况下优先考虑 vector 和 list ， deque 的应用并不多，而 目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构

进阶C++STLstack和queue | deque与priority queue

stack容器

stack 基本概念

stack 常用接口

模拟实现stack类

queue 容器

queue 基本概念

queue 常用接口

模拟实现queue类

优先级队列 - priority queue

priority_queue 的概念

优先级队列的使用

模拟实现priority_queue类

双端队列 - double ended queue

deque容器基本概念

deque构造函数

deque赋值操作

deque大小操作

deque 插入和删除

deque 数据存取

deque 排序

deque，stack 和 queue 的底层默认容器

deque 的缺陷

网站公告

今日签到

热门文章

最新发布

进阶C++__STL__stack和queue | deque与priority queue

stack容器

stack 基本概念

stack 常用接口

模拟实现stack类

queue 容器

queue 基本概念

queue 常用接口

模拟实现queue类

优先级队列 - priority queue

priority_queue 的概念

优先级队列的使用

模拟实现priority_queue类

双端队列 - double ended queue

deque容器基本概念

deque构造函数

deque赋值操作

deque大小操作

deque 插入和删除

deque 数据存取

deque 排序

deque，stack 和 queue 的底层默认容器

deque 的缺陷

网站公告

今日签到

热门文章

最新发布

进阶C++STLstack和queue | deque与priority queue