C++--stack和queue

栈（stack）

1. stack 是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行

元素的插入与提取操作。

2. stack 是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定

的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部 ( 即栈顶 ) 被压入和弹出。

3. stack 的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：

empty ：判空操作

back ：获取尾部元素操作

push_back ：尾部插入元素操作

pop_back ：尾部删除元素操作

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

默认情况下使用 deque 。

stack的定义方式

方式一： 使用默认的适配器定义栈。

stack<int> st1;

方式二： 使用特定的适配器定义栈。

stack<int, vector<int>> st2;
stack<int, list<int>> st3;

stack的使用

#include <iostream>
#include <stack>

int main() {
    std::stack<int> myStack;

    // 检查栈是否为空
    if (myStack.empty()) {
        std::cout << "栈为空" << std::endl;
    } else {
        std::cout << "栈不为空" << std::endl;
    }

    // 尾部插入元素
    myStack.push(1);
    myStack.push(2);
    myStack.push(3);

    // 获取尾部元素
    std::cout << "尾部元素：" << myStack.back() << std::endl;

    // 尾部删除元素
    myStack.pop();
    std::cout << "删除尾部元素后，新的尾部元素：" << myStack.back() << std::endl;

    return 0;
}

代码运行结果:

栈为空
尾部元素：3
删除尾部元素后，新的尾部元素：2

 队列(queue)

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

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

素 ) 。

3. 优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类， queue 提供一组特

定的成员函数来访问其元素。元素从特定容器的 “ 尾部 ” 弹出，其称为优先队列的顶部。

4. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭

代器访问，并支持以下操作：

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

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

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

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

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

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

定容器类，则使用 vector 。

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

queue的定义方式

方式一： 使用默认的适配器定义队列。

queue<int> q1;

方式二： 使用特定的适配器定义队列。

queue<int, vector<int>> q2;
queue<int, list<int>> q3;

queue的使用

#include <iostream>
#include <queue>

int main() {
    // 创建两个队列
    std::queue<int> queue1;
    std::queue<int> queue2;

    // 判断队列是否为空
    std::cout << "queue1 是否为空：" << (queue1.empty() ? "是" : "否") << std::endl;

    // 队尾入队列
    queue1.push(1);
    queue1.push(2);
    queue1.push(3);

    // 获取队列中有效元素个数
    std::cout << "queue1 中有效元素个数：" << queue1.size() << std::endl;

    // 获取队头元素和队尾元素
    std::cout << "queue1 队头元素：" << queue1.front() << std::endl;
    std::cout << "queue1 队尾元素：" << queue1.back() << std::endl;

    // 队头出队列
    queue1.pop();
    std::cout << "队头出队列后，新的队头元素：" << queue1.front() << std::endl;

    // 交换两个队列中的数据
    queue2.push(4);
    queue2.push(5);
    std::cout << "queue2 中有效元素个数：" << queue2.size() << std::endl;
    std::cout << "交换前：" << std::endl;
    std::cout << "queue1: ";
    while (!queue1.empty()) {
        std::cout << queue1.front() << " ";
        queue1.pop();
    }
    std::cout << std::endl;
    std::cout << "queue2: ";
    while (!queue2.empty()) {
        std::cout << queue2.front() << " ";
        queue2.pop();
    }
    std::cout << std::endl;

    queue1.push(6);
    queue2.push(7);
    std::cout << "交换后：" << std::endl;
    queue1.swap(queue2);
    std::cout << "queue1: ";
    while (!queue1.empty()) {
        std::cout << queue1.front() << " ";
        queue1.pop();
    }
    std::cout << std::endl;
    std::cout << "queue2: ";
    while (!queue2.empty()) {
        std::cout << queue2.front() << " ";
        queue2.pop();
    }
    std::cout << std::endl;

    return 0;
}

运行结果：

queue1 是否为空：是
queue1 中有效元素个数：3
queue1 队头元素：1
queue1 队尾元素：3
队头出队列后，新的队头元素：2
queue2 中有效元素个数：2
交换前：
queue1: 
queue2: 4 5 
交换后：
queue1: 4 5 
queue2: 6 7