STL 常用容器

vector：动态数组

向量（vector）：向量是一个可变大小的数组，支持快速的随机访问和在末尾进行元素的插入和删除。适用于需要高效的随机访问和动态调整大小的情况，例如存储大量元素且需要频繁地进行插入、删除、随机访问的场景。

#include <iostream>
#include <vector>
using namespace std;
int main()
{
    vector<int> vec;
    vec.push_back(10); // 添加元素到末尾
    vec.push_back(9);  // 添加元素到末尾
    int el = vec[0]; // 随机访问元素
    vec.pop_back(); // 移除末尾元素
}

list：双向链表

链表（list）：链表是由节点组成的数据结构，每个节点包含一个元素和一个指向下一个节点的指针。与vector相比，链表支持高效的插入和删除操作，但不支持随机访问。适用于需要频繁的插入和删除操作，但不需要随机访问的场景。

#include <iostream>
#include <list>
using namespace std;
int main()
{
    std::list<int> myList;
    myList.push_back(10);  // 在末尾插入元素
    myList.push_front(20); // 在头部插入元素
    myList.pop_back();     // 移除末尾元素
    myList.pop_front();    // 移除头部元素
}

deque：双端队列

双端队列（deque）：双端队列是一种支持在两端进行插入和删除操作的序列容器。适用于需要在两端进行频繁插入和删除操作的场景，同时需要支持随机访问。

#include <iostream>
#include <deque>

using namespace std;
int main()
{
    deque<int> myDeque;
    myDeque.push_back(10);  // 在末尾插入元素
    myDeque.push_front(20); // 在头部插入元素
    myDeque.pop_back();     // 移除末尾元素
    myDeque.pop_front();    // 移除头部元素
}

stack：栈

栈（stack）：栈是一种后进先出（LIFO）的容器，只允许在栈顶插入和删除元素。适用于需要按照后进先出的顺序处理元素的场景，如函数调用、表达式求值等。

#include <iostream>
#include <stack>

using namespace std;
int main()
{
    stack<int> myStack;
    myStack.push(10);               // 元素入栈
    int topElement = myStack.top(); // 访问栈顶元素
    myStack.pop();                  // 元素出栈
    bool isEmpty = myStack.empty(); // 检查栈是否为空
}

queue：队列

队列（queue）：队列是一种先进先出（FIFO）的容器，只允许在队尾插入元素，在队头删除元素。适用于需要按照先进先出的顺序处理元素的场景，如任务调度、消息传递等。

#include <iostream>
#include <queue>

using namespace std;
int main()
{
    queue<int> myQueue;
    myQueue.push(10);                   // 元素入队
    int frontElement = myQueue.front(); // 访问队首元素
    myQueue.pop();                      // 元素出队
    bool isEmpty = myQueue.empty();     // 检查队列是否为空
}

priority_queue：优先队列 heap：堆

优先队列（Priority Queue）是一种特殊的队列，每个元素都有一个与之相关的优先级。优先队列的特点是每次取出的元素都是具有最高优先级的元素。

它可以用多种底层数据结构来实现，其中最常用的底层数据结构之一就是堆（Heap）。

堆是一种具有特殊性质的树状数据结构，通常用数组来表示。堆分为最大堆（Max Heap）和最小堆（Min Heap）两种类型。在最大堆中，父节点的值大于或等于其子节点的值；在最小堆中，父节点的值小于或等于其子节点的值。这样的性质使得堆中的根节点（位于数组的第一个元素）具有最高（或最低）优先级，因此非常适合用于实现优先队列。

#include <iostream>
#include <queue>

using namespace std;
int main()
{
    priority_queue<int> myPriorityQueue;
    myPriorityQueue.push(10);               // 元素入队
    int topElement = myPriorityQueue.top(); // 访问队列中的最高优先级元素
    myPriorityQueue.pop();                  // 元素出队
    bool isEmpty = myPriorityQueue.empty(); // 检查队列是否为空
    // 其他
    vector<int> vec = {1,2,3,4,5,6};
    // 小堆则第三个参数设为greater<int>()
    make_heap(vec.begin(), vec.end());
    /* 将堆的最大（或最小）元素移动到容器的最后一个位置，并保持堆的性质不变。换句话说，它将堆中的根节点（通常是最大值或最小值）移动到最后一个节点，并将堆的大小减小一个元素。*/
    pop_heap(vec.begin(), vec.end());
    vec.pop_back();
    vec.push_back(0);
    /*将容器中的元素进行重新排列，以将新添加的元素（通常是最后一个元素）正确地放入堆中，并保持堆的性质不变。*/
    push_heap(vec.begin(), vec.end());
}

map：映射

映射（map）：映射是一种键值对的容器，其中的元素按照键的顺序排列。可以根据键快速地查找、插入和删除元素，适用于需要根据键进行快速查找的场景。

#include <iostream>
#include <unordered_map>
#include <string>

int main() {
    std::unordered_map<std::string, int> myMap;

    // 插入键值对
    myMap["apple"] = 5;
    myMap["banana"] = 3;
    myMap["orange"] = 8;

    // 访问元素
    std::cout << "apple: " << myMap["apple"] << std::endl;
    std::cout << "banana: " << myMap["banana"] << std::endl;
    std::cout << "orange: " << myMap["orange"] << std::endl;

    // 遍历哈希表
    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // 检查元素是否存在
    if (myMap.find("apple") != myMap.end()) {
        std::cout << "apple exists" << std::endl;
    }

    // 删除元素
    myMap.erase("banana");

    // 检查元素是否存在
    if (myMap.find("banana") == myMap.end()) {
        std::cout << "banana does not exist" << std::endl;
    }

    return 0;
}