STL 笔记（十）：容器适配器——队列和堆栈

#include 
#include 
#include 
#include 
#include 
#include 

using namespace std;

// 序列型  关联型  容器适配器  bitset
// vector  set     stack
// deque   map     queue
// list            priority_queue

// 容器适配器：在序列型容器的基础上封装为栈、队列或优先队列

// stack - 先进后出 - 无迭代器
// 封装的基本容器：deque（默认）、vector、list
// 封装的基本操作：empty、size、top、push、pop

void test1()
{
    stack s1; // deque
    vector v(2); // 0 0
    stack > s2(v); // vector

    cout << s2.empty() << endl;
    cout << s2.size() << endl;
    cout << s2.top() << endl; // 0
    s2.push(3);
    s2.push(4);
    cout << s2.top() << endl; // 4
    s2.pop();
    cout << s2.top() << endl; // 3

    // 遍历出栈
    while (!s2.empty()) {
        cout << s2.top() << ' ';
        s2.pop();
    }
}

// queue - 先进先出 - 无迭代器
// 封装的基本容器：deque（默认）、list
// 封装的基本操作：empty、size、front、back、push、pop

void test2()
{
    queue q1;
    list l;
    l.push_back(3);
    l.push_back(4);
    queue > q2(l);

    cout << q2.empty() << endl; // 0
    cout << q2.size() << endl;  // 2
    cout << q2.front() << endl; // 3
    cout << q2.back() << endl;  // 4
    q2.push(5);
    q2.push(6);
    q2.push(7);
    cout << q2.size() << endl;  // 5
    cout << q2.front() << endl; // 3
    cout << q2.back() << endl;  // 7
    q2.pop();
    q2.pop();
    cout << q2.size() << endl;  // 3
    cout << q2.front() << endl; // 5
    cout << q2.back() << endl;  // 7

    // 遍历队列
    while(!q2.empty()) {
        cout << q2.front() << ' ';
        q2.pop();
    }
}

int main()
{
    // 容器适配器
    test1(); // 堆栈
    test2(); // 队列

    return 0;
}

#include 
#include 
#include 
#include 

using namespace std;

// 括号匹配
class Match
{
private:
    string bracket;
public:
    Match(string s): bracket(s) {}
    void matchBracket()
    {
        stack stk;
        int i = 0, flag = 0; // 匹配 · 0 | 不匹配 · 1
        for (; i < bracket.size(); i++) {
            char c = bracket[i];
            switch(c)
            {
            case '[':
                stk.push(c);
                break;
            case '(':
                stk.push(c);
                break;
            case ')':
                if (!stk.empty() && stk.top() == '(') {
                    stk.pop();
                } else {
                    flag = 1;
                }
                break;
            case ']':
                if (!stk.empty() && stk.top() == '[') {
                    stk.pop();
                } else {
                    flag = 1;
                }
                break;
            }
            if (flag == 1) break;
        }
        if (flag == 0 && stk.empty()) { // 极端情况：只有左括号或只有右括号
            cout << "匹配成功！" << endl;
        } else { // 只有左括号，只有右括号，括号不匹配
            cout << "匹配失败！" << endl;
        }
    }
};

class YHTriangle
{
private:
    int rowNum;
public:
    YHTriangle(int n): rowNum(n) {}
    void printYHTriangle()
    {
        int s, t;
        queue q;
        cout << '1' << endl; // 第一行
        q.push(0);
        q.push(1);
        q.push(1); // 第二行
        for (int i = 0; i < rowNum - 2; i++) { // 打印第二行内容的同时生成第三行
            q.push(0); // 0表示每行的界值（每行的开始）| 零的左右总是一，用来生成每行开始和结束位置的一
            do
            {
                s=q.front();
                q.pop();
                t=q.front();
                q.push(s+t);
                if(t) {
                    cout< 
总结 
栈和队列均是容器适配器，即在序列型容器的基础上进行功能上的封装，而封装的容器和功能取决于容器适配器本身的特性
根据容器适配器本身的特性，对底层所封装的序列型容器具有一定的限制，例如，对于队列，其底层只能使用 deque 与 list，而不能使用 vector，因为队列是需要在队头和队尾都可以进行操作的数据结构，而 vector 的操作只能在容器尾部进行
 
 
 
在下一篇文章，我们将介绍 C++ 中的容器适配器——优先队列
 
 
后记 
此文章主要用来作为课程学习过程中的总结，大家如果有什么问题也可以在评论区留言，我会尽力帮大家解决问题，如果觉得对大家有帮助的话，希望多多点赞、转发，谢谢！