C++ 常见的STL容器

目录

1.vector（数组）

常见的底层实现方式：

队列的增删查改的应用：

二维数组

2.stack（栈）

3.queue（队列）

4.queue_priority（优先级队列）

---

1.vector（数组）

用于存储和操作动态数组。它提供了可变大小的数组，可以在运行时根据需要自动调整大小。

在使用vector时需要使用头文件#include<vector>。

常见的底层实现方式：

数组：在某些编程语言中，Vector 可能是通过数组实现的。数组是一块连续的内存区域，可以按索引直接访问元素。当 Vector 需要调整大小时，可能需要重新分配更大的内存块，并将原始元素复制到新的内存中。

链表：另一种实现 Vector 的方式是使用链表。链表是由节点组成的数据结构，每个节点包含一个元素和一个指向下一个节点的指针。当 Vector 需要添加或删除元素时，可以通过修改节点之间的指针来实现动态大小的调整。

动态数组：动态数组是一种结合了数组和链表的特点的数据结构。它使用数组来存储元素，并且在需要调整大小时，可以重新分配更大的数组，并将原始元素复制到新的数组中。这种方式在实现上比纯数组更灵活，因为它可以根据需要在数组的末尾进行添加和删除操作。

队列的增删查改的应用：

#include <iostream>
#include <vector>

using namespace std;

int main() {
    // 创建一个空的 vector
    vector<int> vec;

    // 添加元素到 vector 尾部
    vec.push_back(10);
    vec.push_back(20);
    vec.push_back(30);

    // 获取 vector 的大小
    cout << "Vector size: " << vec.size() << endl;

    // 遍历 vector 并打印元素
    cout << "Vector elements: ";
    for (const auto& element : vec) {
        cout << element << " ";
    }
    cout << endl;

    // 修改 vector 中的元素
    vec[1] = 50;

    // 查找元素的索引
    auto it = find(vec.begin(), vec.end(), 30);
    if (it != vec.end()) {
        int index = distance(vec.begin(), it);
        cout << "Element 30 found at index: " << index << endl;
    } else {
        cout << "Element 30 not found in the vector" << endl;
    }

    // 删除 vector 中的元素
    vec.erase(vec.begin() + 2);

    // 再次遍历 vector 并打印元素
    cout << "Updated vector elements: ";
    for (const auto& element : vec) {
        cout << element << " ";
    }
    cout << endl;

    return 0;
}

二维数组

#include <iostream>
#include <vector>

using namespace std;

int main() {
    // 创建一个二维数组
    vector<vector<int>> matrix{
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // 访问二维数组的元素
    cout << "Element at matrix[1][2]: " << matrix[1][2] << endl;

    // 修改二维数组的元素
    matrix[0][1] = 10;

    // 打印二维数组的所有元素
    cout << "Matrix elements: " << endl;
    for (const auto& row : matrix) {
        for (const auto& element : row) {
            cout << element << " ";
        }
        cout << endl;
    }

    return 0;
}

2.stack（栈）

具有先进后出的特点，就像一个杯子，最先进去的在杯底，所以会先进后出。

#include <iostream>
#include <stack>

using namespace std;

int main() {
    stack<int> myStack;

    // 将元素推入栈
    myStack.push(1);
    myStack.push(2);
    myStack.push(3);

    // 获取栈顶元素
    int topElement = myStack.top();
    cout << "Top element: " << topElement << endl;

    // 弹出栈顶元素
    myStack.pop();

    // 检查栈是否为空
    bool isEmpty = myStack.empty();
    cout << "Is stack empty? " << (isEmpty ? "Yes" : "No") << endl;

    // 获取栈的大小
    size_t stackSize = myStack.size();
    cout << "Stack size: " << stackSize << endl;

    return 0;
}

3.queue（队列）

是一种先进先出（FIFO）的数据结构，类似于现实生活中的排队。在队列中，元素从队列的一端（队尾）进入，从另一端（队首）出去。只能在队尾添加元素，在队首移除元素。

#include <iostream>
#include <queue>

using namespace std;

int main() {
    queue<int> myQueue;

    // 将元素推入队列
    myQueue.push(1);
    myQueue.push(2);
    myQueue.push(3);

    // 获取队首元素
    int frontElement = myQueue.front();
    cout << "Front element: " << frontElement << endl;

    // 移除队首元素
    myQueue.pop();

    // 检查队列是否为空
    bool isEmpty = myQueue.empty();
    cout << "Is queue empty? " << (isEmpty ? "Yes" : "No") << endl;

    // 获取队列的大小
    size_t queueSize = myQueue.size();
    cout << "Queue size: " << queueSize << endl;

    return 0;
}

4.queue_priority（优先级队列）

#include <iostream>
#include <queue>

using namespace std;

int main() {
    priority_queue<int> myPriorityQueue;

    // 将元素推入优先级队列
    myPriorityQueue.push(3);
    myPriorityQueue.push(1);
    myPriorityQueue.push(2);

    // 获取队首元素（最大元素）
    int topElement = myPriorityQueue.top();
    cout << "Top element: " << topElement << endl;

    // 移除队首元素
    myPriorityQueue.pop();

    // 检查优先级队列是否为空
    bool isEmpty = myPriorityQueue.empty();
    cout << "Is priority queue empty? " << (isEmpty ? "Yes" : "No") << endl;

    // 获取优先级队列的大小
    size_t queueSize = myPriorityQueue.size();
    cout << "Priority queue size: " << queueSize << endl;

    return 0;
}