目录

一、vector

1.vector的定义和特性

2.vector的常用函数

3.vector排序去重

二、map

1.map

2.multimap

3.unordered_map

三、stack

1.stack的定义和结构

四、pair

1.pair的定义和结构

2.pair的嵌套

3.pair自带的排序规则

---

一、vector

1.vector的定义和特性

C++中，vector是一个动态数组容器，可以存储一系列相同类型的元素，它是标准库<vector>中定义的模板类。
vector的定义和结构非常简单，它由以下几个重要的部分组成:模板类声明:vector是一个模板类，因此在使用之前需要包含头文件<vector>。声明一个vector对象的通用语法如下:

std::vector<T> vec;

//这里的T是要存储在vector中的元素类型。

容器大小:vector是一个动态数组，可以根据需要自动调整大小。它会根据元素的数量动态分配内存空间。

元素访问:可以通过索引来访问vector中的元素。索引从0开始，最后一个元素的索引是size()1。可以使用[]运算符或at()函数来访问元素。

元素添加和删除:可以使用pushback()函数在vector的末尾添加元素，使用popback()函数删除末尾的元素。还可以使用insert()函数在指定位置插入元素，使用eraseO函数删除指定位置的元素。

容器大小管理:可以使用size()函数获取vector中元素的数量，使用empty()函数检查vector是否为空。还可以使用resize()函数调整vector的大小。

迭代器:vector提供了迭代器，可以用于遍历容器中的元素。可以使用begin0函数获一个元素的迭代器，使用end()函数获取指向最后一个元素之后位置的迭代器。

2.vector的常用函数

push back():将元素添加到vector的末尾。

void push_ back(const T& value);
 

pop_back():删除vector末尾的元素

void pop_back();

begin()和end():返回指向vector第一个元素和最后一个元素之后位置的迭代器。
示例:
vector<int> vec = {10, 20, 30};

for (auto it = vec begin(); it != vec.end(); ++it)

{
  cout << "it << " ";

}
 

3.vector排序去重

排序:

要对vector进行排序，可以使用标准库中的sort函数。该函数位于头文件<algorithm>中。

示例:

#include <algorithm>

std::vector<T> vec ={...};

std::sort(vec.begin(),vec.end());

这里的T是vector中元素的类型。

sort函数接受两个迭代器参数，表示要排序的范围。

vec.begin()返回指向vector第一个元素的迭代器

vec.end()返回指向最后一个元素之后位置的迭代器。

去重:要去除vector中的重复元素，可以使用std::unique函数。该函数位于头文件<algorithm>中

示例:

#include <algorithm>

std::vector<T> vec ={...};

std::sort(vec.begin(),vec.end());

auto last = std::unique(vec.begin(), vec.ebd());

vec.erase(last, vec.end());

首先，需要对vector进行排序，以便相同的元素相邻。然后，std::unique函数将重复的元素移动到vector的末尾，并返回一个指向不重复元素的迭代器。最后，可以使用vec.erase函数将重复元素从vector中删除

示例:
#include<iostream>

#include <vector>

#include <algorithm>

int main()

{
    std::vector<int> vec = {2，1，3，2，4，1，5，4);

    std::sort(vec,begin(),vec.end());

    auto last = std::unique(vec.begin(),vec.end());

     vec.erase(last, vec.end());
            for(const auto& num:vec)

                 {

                   std::cout << num<<” ";
                 }

     return 0;

}

输出:
12345

这样，vector中的重复元素被去除，只保留了不重复的元素，

二、map

1.map

map是一种关联容器，用于存储一组键值对(key-value pairs)，其中每个键(key)都是唯一的。

map容器根据键来自动进行排序，并且可以通过键快速查找对应的值。map容器使用红黑树(Red-Black Tree)数据结构来实现，具有较快的插入、删除和査找操作的时间复杂度0(logn)。

map的定义和结构如下:

template < class Key, class T,class Compare = less<Key>,

                  class Allocator = allocator<pair<const Key, T>>>
          class map ;

Key: 表示存储在map中的键(key)的类型

T: 表示存储在map中的值(value)的类型:
Compare: 表示用于比较键的函数对象的类型，默认为less，使用键类型的默认比较函数

Allocator: 表示用于分配内存的分配器类型，默认为allocator。

函数 insert erase find count size begin end clear empty lower_bound upper_bound

功能 插入元素 删除元素 查找元素 统计元素个数 返回元素个数 返回指向容器起始位置的选代器 返回指向容器未尾位置的迭代器 清空容器 判断容器是否为空 返回指向第一个不小于指定键的元素位置  返回指向第一个大于指定键的元素位置

时间复杂度 o(log n) o(log n) o(log n) o(log n) o(1) o(1) o(1) o(n) O(1) o(log n) o(log n)

2.multimap

multimap是一种关联容器，类似于map，但允许存储多个具有相同键的键值对。

在实际做题过程中，multimap几乎用不到。

3.unordered_map

unordered_map是一种关联容器，用于存储一组键值对(key-value pairs)，其中每个键(key)都是唯一的。与map和mwultimap不同，umordered_map不会根据键的顺序进行排序，而是使用哈希函数将键映射到存储桶中。这使得unordered_map具有更快的插入、删除和査找操作的时间复杂度，但不保证元素的顺序。

unordered map的定义和结构如下:
emplate <class Key,class T, class Hash = hash<Key>,

                class KeyEqual = equal_to<Key>,
                class Allocator  = allocator<pair<const Key, T>>>
class unordered map;

·Key:表示存储在unorderedmap中的键(key)的类型

·T:表示存储在unorderedmap中的值(value)的类型

·Hash:表示用于计算键的哈希值的函数对象的类型，默认为hash，使用键类型的默认哈希函数。

·KeyEqual:表示用于比较键的函数对象的类型，默认为equal_to，使用键类型的默认比较函数。

·Allocator:表示用于分配内存的分配器类型，默认为allocator。

函数 insert erase find count size empty clear

功能 插入元素 删除元素 查找元素 计数指定键的元素个数 返回元素个数 判断容器是否为空 清空容器

平均时间复杂度 0(1) o(1) 0(1) 0(1) 0(1) 0(1) 0(1)

最坏时间复杂度簣浗頑还 0(n) 0(m) 0(m) 0(m) 0(1) 0(1) o(n)

unordered map拥有极好的平均时间复杂度和极差的最坏时间复杂度，所以他的时间复杂度是不稳定的。

一般情况下我们更愿意使用复杂度稳定的map而不是unordered map.

三、stack

1.stack的定义和结构

stack是一种后进先出(LIF0)的数据结构，使用前需要包含头文件<stack>。stack提供了一组函数来操作和访问元素，但它的功能相对较简单。stack的定义和结构如下:

template<class T, class Container = deque<T>>

              class stack;
 

template<class T,class (ontainer = deque<T>>

              class stack;
 

T: 表示存储在stack中的元素的类型。
 

Container: 表示底层容器的类型，默认为deque。也可以使用其他容器类型，如vector或list。
stack的内部实现使用了底层容器来存储元素，并且只能通过特定的函数来访问和操作元素。

函数 push(x) pop() top() empty() size()

描述 在栈顶插入元素 x 弹出栈顶元素 返回栈顶元素 检查栈是否为空 empty()检查栈是否为空

时间复杂度 0(1) 0(1) o(1) 0(1) 0(1)

四、pair

1.pair的定义和结构

在C++中，pair是一个模板类，用于表示一对值的组合。它位于<utility>头文件中。

pair类的定义如下:

template<class T1, class T2>

struct pair

{

    T1 first;          // 第一个值
    T2 second;    // 第二个值

//构造函数      

   pair();

         pair(const T1&  x, const T2&  y);

     //比较运算符重载

        bool operator == (const pair& rhs)const;

        bool operator != (const pair& rhs)const;
}

pair类模板有两个模板参数，T1和T2，分别表示第一个值和第二个值的类型。

pair类有两个成员变量，first和second，分别表示第一个值和第二个值。

pair类还有一些成员函数和特性，例如默认构造函数、带参数的构造函数、比较运算符重载等。

使用pair类，你可以方便地将两个值组合在一起，并进行传递、存储和操作。

例如，可以将两个整数组合在一起作为回值，或者将一对值存储在容器中。

下面是一些使用pair的示例:

#include<iostream>

#include <utility>

int main()

{

        std::pair<int, double> p1(1, 3.14);

        std: :pair<char, std::string> p2('a', "hello");

        std: :cout << p1.first <<“,"<<p1.second << std::endl;

        std::cout << p2.first<<","<<p2.second << std: :endl;
         

     return 0;

}
以上代码创建了两个pair对象，分别包含不同类型的值。然后，通过访问first和second成员变量，输出了这些值

2.pair的嵌套

pair可以进行嵌套，也就是说可以将一个pair对象作为另一个pair对象的成员。通过嵌套pair，你可以方便地组合多个值，并形成更复杂的数据结构。

例如，你可以创建一个三维坐标系的点，其中第1个维度由一个整数表示，第2、3个维度由一个pair表示。

下面是一个示例代码，演示了如何嵌套使用pair:

#include <utility>

#include<iostream>

      int main()

   {

     std::pair <int, int> p1(1, 2);

     std::pair <int, std::pair <int, int> > p2(3,  std:: make_pair(4, 5));

     std::pair <std::pair <int, int>, std::pair <int, int> >> p3( std:: make_pair(6, 7), std:: make_pair);
 

    std::cout << p1.first << ", " << p1.second << std:: endl;

    std::cout << p2.first << ", " << p2.second.first << ", "  << p2.second.second << std:: endl;

    std::cout << p3.first .first<< ", " << p3.first. second << ", "  << p3.second. first << " " <<std::            endl;

    return 0;

}

在这个示例中，我们创建了三个pair对象:p1、p2和p3。

·P1是一个简单的pair，包含两个整数值。

·p2是一个嵌套的pair，其中第一个值是一个整数，第二个值是一个pair，其中包含两个整数

·p3是一个嵌套的pair，其中每个值都是一个pair，每个pair包含两个整数值。通过访问嵌套的pair对象的成员变量，我们可以获取到相应的值。

3.pair自带的排序规则

pair自带的排序规则是按照first成员进行升序排序。

如果first成员相等，则按照second成员进行升序排序这意味着当你使用标准库中的排序算法(如std::sort)对包含pair对象的容器进行排序时，会根据pair对象的first成员进行排序。

下面是一个示例代码，演示了如何使用pai进行排序:

#include <iostream>
#include <utility>
#include <vector>
#include <algorithm>

     int main()

   {
     std::vector<std::pair<int, int>> vec
     vec.push back(std::make_pair(3,2));
     vec.push back(std::nake pair(1, 4))
     vec.push back(std::mgke pair(2,1));

    std::sort(vec.begin(), vec.end());

         for(const auto& p : vec)

        {
             std::cout << p.first<<","<< p.second << std: :endl;

        }
     return  0;

}

在这个示例中，我们创建了一个存储pair对象的向量vec，其中包含三个pair对象。然后，我们使用std::sort函数对vec进行排序。由于pair对象的排序规则是按照first成员进行升序排序，所以排序后的结果

           

1	4
2	1
3	2

最后，我们通过遍历vec并输出每个pair对象的成员，验证了排序结果。需要注意的是，如果你想按照其他排序规则对pair进行排序，可以自定义比较函数或使用lambda表达式来传递给排序算法。这样，你可以根据自己的需求定义排序规则