C++ STL中的容器

C++ STL中的容器是一些对象类型，能够在其内部存放不同类型的数据，并在其上执行各种操作。STL中包含多种容器类型，包括序列容器、关联容器和无序容器。每种容器在特定情况下都有其自身的优点和缺点。

序列容器

序列容器是保留了元素之间线性顺序的容器，元素按照它们插入到容器中的顺序进行存储和访问。STL中的序列容器包括vector、list、deque、array、forward_list和string。

vector

vector是一个动态数组，可以在任何时候插入和删除元素，但它的随机访问和插入/删除操作的时间复杂度是O(1)。vector的内部是一个连续的存储空间，支持通过下标随机访问。

#include <vector>
#include <iostream>
using namespace std;

int main() {
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    cout << v[0] << " " << v[1] << " " << v[2] << endl; // 输出 1 2 3
    return 0;
}

list

list是一个双向链表，支持快速的插入和删除操作。list不支持随机访问，只能通过迭代器进行访问。

#include <list>

int main() {
    list<int> l;
    l.push_back(1);
    l.push_front(2);
    l.push_back(3);
    for (auto it = l.begin(); it != l.end(); it++) {
        cout << *it << " "; // 输出 2 1 3
    }
    return 0;
}

deque

deque是一个双端队列，支持快速的在两端插入和删除元素。deque也支持随机访问。

#include <deque>

int main() {
    deque<int> d;
    d.push_back(1);
    d.push_front(2);
    d.push_back(3);
    for (auto it = d.begin(); it != d.end(); it++) {
        cout << *it << " "; // 输出 2 1 3
    }
    return 0;
}

array

array是一个固定大小的数组，可以支持随机访问，但不能插入和删除元素。

#include <array>

int main() {
    array<int, 3> a = {1, 2, 3};
    for (int i = 0; i < a.size(); i++) {
        cout << a[i] << " "; // 输出 1 2 3
    }
    return 0;
}

forward_list

forward_list是一个单向链表，和list类似，但只支持单向遍历。

#include <forward_list>

int main() {
    forward_list<int> f;
    f.push_front(1);
    f.push_front(2);
    f.push_front(3);
    for (auto it = f.begin(); it != f.end(); it++) {
        cout << *it << " "; // 输出 3 2 1
    }
    return 0;
}

string

string是一个字符序列，可以支持随机访问和插入/删除操作。string还支持许多额外的字符串操作，如查找子串和字符串替换。

#include <string>

int main() {
    string s = "Hello";
    s += " World";
    cout << s << endl; // 输出 Hello World
    return 0;
}

关联容器

关联容器是按照键来存储和访问元素的容器，STL中的关联容器包括set、multiset、map和multimap。

set

set是一个集合，其中的元素唯一且按照某个键值的升序排序。

#include <set>

int main() {
    set<int> s;
    s.insert(3);
    s.insert(2);
    s.insert(1);
    for (auto it = s.begin(); it != s.end(); it++) {
        cout << *it << " "; // 输出 1 2 3
    }
    return 0;
}

multiset

multiset是一个可以包含重复元素的集合，其中的元素按照某个键值的升序排序。

#include <set>

int main() {
    multiset<int> ms;
    ms.insert(3);
    ms.insert(2);
    ms.insert(1);
    ms.insert(2);
    for (auto it = ms.begin(); it != ms.end(); it++) {
        cout << *it << " "; // 输出 1 2 2 3
    }
    return 0;
}

map

map是一个映射，其中的元素按照其键的升序排序。

#include <map>

int main() {
    map<string, int> mp;
    mp.insert(make_pair("Alice", 20));
    mp.insert(make_pair("Bob", 21));
    mp.insert(make_pair("Charlie", 22));
    for (auto it = mp.begin(); it != mp.end(); it++) {
        cout << it->first << " " << it->second << endl; // 输出 Alice 20 Bob 21 Charlie 22
    }
    return 0;
}

multimap

multimap是一个可以包含重复键的映射，其中的元素按照其键的升序排序。

#include <map>

int main() {
    multimap<string, int> mmp;
    mmp.insert(make_pair("Alice", 20));
    mmp.insert(make_pair("Bob", 21));
    mmp.insert(make_pair("Alice", 22));
    for (auto it = mmp.begin(); it != mmp.end(); it++) {
        cout << it->first << " " << it->second << endl; // 输出 Alice 20 Alice 22 Bob 21
    }
    return 0;
}

无序容器

无序容器是不保留元素顺序的容器，STL中的无序容器包括unordered_set、unordered_multiset、unordered_map和unordered_multimap。

unordered_set

unordered_set是一个集合，其中的元素唯一且无序。

#include <unordered_set>

int main() {
    unordered_set<int> s;
    s.insert(3);
    s.insert(2);
    s.insert(1);
    for (auto it = s.begin(); it != s.end(); it++) {
        cout << *it << " "; // 输出 2 1 3，顺序是不确定的
    }
    return 0;
}

unordered_multiset

unordered_multiset是一个可以包含重复元素的集合，其中的元素无序。

#include <unordered_set>

int main() {
    unordered_multiset<int> ms;
    ms.insert(3);
    ms.insert(2);
    ms.insert(1);
    ms.insert(2);
    for (auto it = ms.begin(); it != ms.end(); it++) {
        cout << *it << " "; // 输出 2 1 2 3，顺序是不确定的
    }
    return 0;
}

unordered_map

unordered_map是一个映射，其中的元素无序。

#include <unordered_map>

int main() {
    unordered_map<string, int> mp;
    mp.insert(make_pair("Alice", 20));
    mp.insert(make_pair("Bob", 21));
    mp.insert(make_pair("Charlie", 22));
    for (auto it = mp.begin(); it != mp.end(); it++) {
        cout << it->first << " " << it->second << endl; // 输出 Charlie 22 Alice 20 Bob 21，顺序是不确定的
    }
    return 0;
}

unordered_multimap

unordered_multimap是一个可以包含重复键的映射，其中的元素无序。

#include <unordered_map>

int main() {
    unordered_multimap<string, int> mmp;
    mmp.insert(make_pair("Alice", 20));
    mmp.insert(make_pair("Bob", 21));
    mmp.insert(make_pair("Alice", 22));
    for (auto it = mmp.begin(); it != mmp.end(); it++) {
        cout << it->first << " " << it->second << endl; // 输出 Alice 20 Alice 22 Bob 21，顺序是不确定的
    }
    return 0;
}

总之，STL中的容器提供了强大的数据结构支持，可以帮助我们方便地存储和操作数据。在选择容器的时候，我们需要考虑到特定的需求，选择最适合解决问题的容器。