c++容器各种用法总结

ゝ一纸荒年。 2023-07-21 14:29 20阅读 0赞

### 文章目录 ###

*  一些共有方法或者特性
 *   *   *  find函数
         *  size
 *  stack
 *   *   *  1、出栈：如 s.pop() 注意并不返回出栈的元素
         *  2、进栈：如 s.push(x)
         *  3、访问栈顶元素：如s.top();
         *  4、判断栈空：如 s.empty() 栈为空时返回true
         *  5、返回栈中元素个数，如：s.size()
 *  vector
 *   *   *  find
         *  assign
         *  插入元素
         *  1、push\_back(x) 在数组的最后添加元素x。
         *  2、pop\_back() 删除最后一个元素，无返回值。
         *  3、at(i) 返回位置i的元素。
         *  4、begin() 返回一个迭代器，指向第一个元素。
         *  5、end() 返回一个迭代器，指向最后一个元素的下一个位置。
         *  6、front() 返回数组头的引用。
         *  7、capacity(x) 为vector分配空间
         *  8、size() 返回数组大小
         *  9、resize(x) 改变数组大小，如果x比之前分配的空间大，则自动填充默认值。
         *  10、insert 插入元素
         *  11、erase 删除元素
         *  12、rbegin() 返回一个逆序迭代器，它指向最后一个元素。
         *  13、rend() 返回一个逆序迭代器，它指向的第一个元素前面的位置。
         *  14、clear()清空所有元素。
 *  set
 *   *   *  1、begin() 返回一个迭代器，指向第一个元素。
         *  2、end() 返回一个迭代器，指向最后一个元素的下一个位置。
         *  3、clear()清空set的所有元素。
         *  4、empty() 判断是否为空。
         *  5、size() 返回当前元素个数
         *  6、erase(it) 删除迭代器指针it指向的元素。
         *  7、insert(a) 插入元素a
         *  8、count() 查找某个元素出现的次数，只有可能为0或1。
         *  9、find() 查找某个元素出现的位置，如果找到则返回这个元素的迭代器，如果不存在，则返回s.end()
 *  queue
 *   *   *  1、入队，如：q.push(x) 将元素x置于队列的末端
         *  2、出队，如: q.pop() 同样不会返回弹出元素的值
         *  3、返回队首元素，如：q.front();
         *  4、返回队尾元素，如：q.back();
         *  5、判断是否为空，如：q.empty();
         *  6、返回队列元素个数，如：q.size();
 *  priority\_queue
 *  deque
 *   *   *  c.size(); //返回当前的元素数量
         *  c.empty(); //判断大小是否为零。等同于c.size() == 0,但可能更快
         *  c.max\_size(); //可容纳元素的最大数量
         *  c.at(idx) ; //返回索引为idx所标示的元素。如果idx越界，抛出out\_of\_range
         *  c\[idx\] ; //返回索引idx所标示的元素。不进行范围检查
         *  c.front() ; //返回第一个元素,不检查元素是否存在
         *  c.back(); //返回最后一个元素
         *  c.begin(); //返回一个随机迭代器，指向第一个元素
         *  c.end(); //返回一个随机迭代器，指向最后元素的下一位置
         *  c.assign(n , elem); //将n个elem副本赋值给c
         *  c.assing(beg , end); //将区间\[beg;end\]中的元素赋值给c;
         *  c.push\_back(elem); //在尾部添加元素elem
         *  c.pop\_back() ; //移除最后一个元素（但不回传）
         *  c.push\_front() ; //在头部添加元素elem
         *  c.pop\_front() ; //移除头部一个元素（但不回传）
         *  c.erase(pos) ; //移除pos位置上的元素，返回一元素位置
         *  c.insert(pos , elem); //在pos位置插入一个元素elem，并返回新元素的位置
         *  c.insert(pos , n , elem); //在pos位置插入n个元素elem，无返回值
         *  c.insert(pos , beg , end);
         *  c.resize(num); //将容器大小改为num。可更大或更小。
         *  c.resize(num , elem); //将容器大小改为num，新增元素都为 elem
         *  c.clear(); //移除所有元素，将容器清空
 *  哈希表unordered\_map
 *   *   *  支持key的类型
         *  添加元素
         *  根据索引key提取value
         *  使用find查找value
 *  list(双向链表)
 *   *   *  2.1list中的构造函数：
         *  2.2 begin()和end()：
         *  2.3 push\_back() 和push\_front()：
         *  2.4 empty()：
         *  2.5 resize()：
         *  2.6 clear()：
         *  2.7 front()和back()：
         *  2.8 pop\_back和pop\_front()：
         *  2.9 assign()：
         *  2.10 swap()：
         *  2.11 reverse()：
         *  2.12 merge()：
         *  splice方法

# 一些共有方法或者特性 #

### find函数 ###

### size ###

注意的是，返回的是一个size\_t的数据类型，不是直接的int，所以建立都用一个int去接它，而不是直接使用，比如放在max中，无法与int直接比较的

# stack #

### 1、出栈：如 s.pop() 注意并不返回出栈的元素 ###

### 2、进栈：如 s.push(x) ###

### 3、访问栈顶元素：如s.top(); ###

### 4、判断栈空：如 s.empty() 栈为空时返回true ###

### 5、返回栈中元素个数，如：s.size() ###

# vector #

### find ###

在vector中没有专门定义的find，所以在vec中查找时要使用统一的find函数

find(v.begin(),v.end(),t)//返回迭代器，减去v.begin()可得到位置

注意与哈希表的内置查找用法区分开

mp.find(t)

### assign ###

一般用来进行部分拷贝或者转移较为好用

v.assign(v1.begin()+1,v1.begin()+3);

### 插入元素 ###

首先要说明，在遍历的时候是绝对不能插入的，不然会导致迭代器的混乱，只能在静态情况下插入

vector.insert(vector.begin(), 5);

### 1、push\_back(x) 在数组的最后添加元素x。 ###

### 2、pop\_back() 删除最后一个元素，无返回值。 ###

### 3、at(i) 返回位置i的元素。 ###

### 4、begin() 返回一个迭代器，指向第一个元素。 ###

### 5、end() 返回一个迭代器，指向最后一个元素的下一个位置。 ###

### 6、front() 返回数组头的引用。 ###

### 7、capacity(x) 为vector分配空间 ###

### 8、size() 返回数组大小 ###

### 9、resize(x) 改变数组大小，如果x比之前分配的空间大，则自动填充默认值。 ###

### 10、insert 插入元素 ###

①a.insert(a.begin(),10); 将10插入到a的起始位置前。  
②a.insert(a.begin(),3,10) 将10插入到数组位置的0-2处。

### 11、erase 删除元素 ###

①a.erase(a.begin()); 将起始位置的元素删除。  
②a.erase(a.begin(),begin()+2); 将0~2之间的元素删除。

### 12、rbegin() 返回一个逆序迭代器，它指向最后一个元素。 ###

### 13、rend() 返回一个逆序迭代器，它指向的第一个元素前面的位置。 ###

### 14、clear()清空所有元素。 ###

# set #

### 1、begin() 返回一个迭代器，指向第一个元素。 ###

### 2、end() 返回一个迭代器，指向最后一个元素的下一个位置。 ###

### 3、clear()清空set的所有元素。 ###

### 4、empty() 判断是否为空。 ###

### 5、size() 返回当前元素个数 ###

### 6、erase(it) 删除迭代器指针it指向的元素。 ###

### 7、insert(a) 插入元素a ###

### 8、count() 查找某个元素出现的次数，只有可能为0或1。 ###

### 9、find() 查找某个元素出现的位置，如果找到则返回这个元素的迭代器，如果不存在，则返回s.end() ###

# queue #

### 1、入队，如：q.push(x) 将元素x置于队列的末端 ###

### 2、出队，如: q.pop() 同样不会返回弹出元素的值 ###

### 3、返回队首元素，如：q.front(); ###

### 4、返回队尾元素，如：q.back(); ###

### 5、判断是否为空，如：q.empty(); ###

### 6、返回队列元素个数，如：q.size(); ###

# priority\_queue #

普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。

在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出 （first in, largest out）的行为特征。  
其内部实现是一个堆排序，每次对输入进来的数据按顺序入一个堆中  
top 访问队头元素  
empty 队列是否为空  
size 返回队列内元素个数  
push 插入元素到队尾 (并排序)  
emplace 原地构造一个元素并插入队列  
pop 弹出队头元素  
swap 交换内容  
一个使用优先队列的例子  
定义：priority\_queue<Type, Container, Functional>  
Type 就是数据类型，Container 就是容器类型（Container必须是用数组实现的容器，比如vector,deque等等，但不能用 list。STL里面默认用的是vector），Functional 就是比较的方式，当需要用自定义的数据类型时才需要传入这三个参数，使用基本数据类型时，只需要传入数据类型，默认是大顶堆  
一般是：

//升序队列
    priority_queue <int,vector<int>,greater<int> > q;
    //降序队列
    priority_queue <int,vector<int>,less<int> >q;
    
    //greater和less是std实现的两个仿函数（就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了）

最后这里是个可以自定义的函数cmp，当使用自定义的时候要把三个参数都写上

#include<iostream>
    #include <queue>
    using namespace std;
    int main() 
    {
        
        //对于基础类型 默认是大顶堆
        priority_queue<int> a; 
        //等同于 priority_queue<int, vector<int>, less<int> > a;
        
        //             这里一定要有空格，不然成了右移运算符↓
        priority_queue<int, vector<int>, greater<int> > c;  //这样就是小顶堆
        priority_queue<string> b;
    
        for (int i = 0; i < 5; i++) 
        {
        
            a.push(i);
            c.push(i);
        }
        while (!a.empty()) 
        {
        
            cout << a.top() << ' ';
            a.pop();
        } 
        cout << endl;
    
        while (!c.empty()) 
        {
        
            cout << c.top() << ' ';
            c.pop();
        }
        cout << endl;
    
        b.push("abc");
        b.push("abcd");
        b.push("cbd");
        while (!b.empty()) 
        {
        
            cout << b.top() << ' ';
            b.pop();
        } 
        cout << endl;
        return 0;
    }

class Solution {
        
    public:
        vector<string> findRelativeRanks(vector<int>& nums) {
        
            int n = nums.size(), cnt = 1;
            vector<string> res(n, "");
            priority_queue<pair<int, int>> heap; //定义一个pair类型的堆
            for(int i =0; i <n; i++){
        
                heap.push({
        nums[i], i}); //放入堆中，自动排序
            }
            for(int i = 0; i < n; i++){
        
                int dx = heap.top().second;//依次从堆顶取，取出来的就是当前最大的
                heap.pop();
                if(cnt == 1) res[dx] = "Gold Medal";
                else if(cnt == 2) res[dx] = "Silver Medal";
                else if(cnt == 3) res[dx] = "Bronze Medal";
                else res[dx] = to_string(cnt);
                cnt++;
            }
            return res;
        }
    };

# deque #

容器deque和vector非常相似，操作函数基本一致。它采用动态数组来管理元素，提供随机存取，可以在头尾两端进行快速安插和删除元素操作。特别要注意，除了头尾两端，在任何地方安插与删除元素，都将导致指向deque元素的任何pointers references iterators 失效。  
使用deque时一般是为了使用头尾增加删除的四个函数，vector只提供了一端的两个函数，少了front端

包括的头文件为：

\#include

using namespace std;

声明一个deque时，一般需要前缀std:: ，如std::deque c;

因为类型deque是一个定义在namespace std内的template 。

构造函数：

deque c ; //产生一个空的deque,其中没有任何元素

deque c1(c2); //产生另一个同型deque的副本（所有元素都被拷贝）

deque c(n) ; //产生一个大小为n的deque

deque c(n , elem) ; //产生一个大小为n的deque，

//每个元素值都是elem。

dequer c(begin,end); //产生一个deque，以区间\[begin ; end\]

//做为元素初值

析构函数：

c.~ deque() ;销毁所有元素，并释放内存。

非变动性操作

### c.size(); //返回当前的元素数量 ###

### c.empty(); //判断大小是否为零。等同于c.size() == 0,但可能更快 ###

### c.max\_size(); //可容纳元素的最大数量 ###

### c.at(idx) ; //返回索引为idx所标示的元素。如果idx越界，抛出out\_of\_range ###

### c\[idx\] ; //返回索引idx所标示的元素。不进行范围检查 ###

### c.front() ; //返回第一个元素,不检查元素是否存在 ###

### c.back(); //返回最后一个元素 ###

### c.begin(); //返回一个随机迭代器，指向第一个元素 ###

### c.end(); //返回一个随机迭代器，指向最后元素的下一位置 ###

变动性操作：

c1 = c2 ; //将c2的所有元素赋值给c1;

### c.assign(n , elem); //将n个elem副本赋值给c ###

### c.assing(beg , end); //将区间\[beg;end\]中的元素赋值给c; ###

### c.push\_back(elem); //在尾部添加元素elem ###

### c.pop\_back() ; //移除最后一个元素（但不回传） ###

### c.push\_front() ; //在头部添加元素elem ###

### c.pop\_front() ; //移除头部一个元素（但不回传） ###

### c.erase(pos) ; //移除pos位置上的元素，返回一元素位置 ###

//如 c.erase( c.begin() + 5)  //移除第五个元素

### c.insert(pos , elem); //在pos位置插入一个元素elem，并返回新元素的位置 ###

### c.insert(pos , n , elem); //在pos位置插入n个元素elem，无返回值 ###

### c.insert(pos , beg , end); ###

### c.resize(num); //将容器大小改为num。可更大或更小。 ###

### c.resize(num , elem); //将容器大小改为num，新增元素都为 elem ###

### c.clear(); //移除所有元素，将容器清空 ###

PS:Deque和Vector是智能容器，删除或者增加元素时，其他位置与元素会进行相应的移动。

# 哈希表unordered\_map #

STL中的unordered\_map使用的是哈希表

### 支持key的类型 ###

主要是可以用与《操作符的，向pair这样的是不可以的  
template <> struct hash;  
template <> struct hash;  
template <> struct hash;  
template <> struct hash;  
template <> struct hash<char16\_t>;  
template <> struct hash<char32\_t>;  
template <> struct hash<wchar\_t>;  
template <> struct hash;  
template <> struct hash;  
template <> struct hash;  
template <> struct hash;  
template <> struct hash;  
template <> struct hash;  
template <> struct hash;  
template <> struct hash;  
template <> struct hash;  
template <> struct hash;  
template <> struct hash;  
template struct hash<T\*>;  
template <size\_t N> struct hash<bitset >;  
template <> struct hash;  
template <> struct hash;  
template <> struct hash;  
template <> struct hash;  
template struct hash<vector<bool, Allocator> >;

### 添加元素 ###

map[key] = value;

### 根据索引key提取value ###

注意：当key存在的时候会返回这个key对应的value，而不存在的时候则会直接添加进去这个key并且将value设置为1，**所以这个只适用于确定key存在的情况下，可以先用find进行判断**

### 使用find查找value ###

这两个的功能十分相近所以这里放在一起讲  
map里面find函数的用法和vector还不太一样，是哈希表名加点加find（key），当元素存在时返回一个迭代器，但这个迭代器通常不好直接利用，当不存在返回的是m.end()**所以find通常只用来判断key值是否存在，不用来查找位置，确定存在后可以再使用索引进行提取**  
注意索引是\[\] 而函数用（）

auto k = map.find(key);//返回迭代器
    bool b = map.find(key) == map.end()//判断是否存在

# list(双向链表) #

stl中的list一般实现是双向链表，这样插入删除更加方便；  
但是由于内存不是连续的，使用迭代器时不能对迭代器使用++操作，凡是内存不连续的都不能这样

### 2.1list中的构造函数： ###

list() 声明一个空列表；

list(n) 声明一个有n个元素的列表，每个元素都是由其默认构造函数T()构造出来的

list(n,val) 声明一个由n个元素的列表，每个元素都是由其复制构造函数T(val)得来的

list(n,val) 声明一个和上面一样的列表

list(first,last) 声明一个列表，其元素的初始值来源于由区间所指定的序列中的元素

### 2.2 begin()和end()： ###

通过调用list容器的成员函数begin()得到一个指向容器起始位置的iterator，可以调用list容器的 end() 函数来得到list末端下一位置，相当于：int a\[n\]中的第n+1个位置a\[n\]，实际上是不存在的，不能访问，经常作为循环结束判断结束条件使用。

### 2.3 push\_back() 和push\_front()： ###

使用list的成员函数push\_back和push\_front插入一个元素到list中。其中push\_back()从list的末端插入，而 push\_front()实现的从list的头部插入。

### 2.4 empty()： ###

利用empty() 判断list是否为空。

### 2.5 resize()： ###

如果调用resize(n)将list的长度改为只容纳n个元素，超出的元素将被删除，如果需要扩展那么调用默认构造函数T()将元素加到list末端。如果调用resize(n,val)，则扩展元素要调用构造函数T(val)函数进行元素构造，其余部分相同。

### 2.6 clear()： ###

清空list中的所有元素。

### 2.7 front()和back()： ###

通过front()可以获得list容器中的头部元素，通过back()可以获得list容器的最后一个元素。但是有一点要注意，就是list中元素是空的时候，这时候调用front()和back()会发生什么呢？实际上会发生不能正常读取数据的情况，但是这并不报错，那我们编程序时就要注意了，个人觉得在使用之前最好先调用empty()函数判断list是否为空。

### 2.8 pop\_back和pop\_front()： ###

通过删除最后一个元素，通过pop\_front()删除第一个元素；序列必须不为空，如果当list为空的时候调用pop\_back()和pop\_front()会使程序崩掉。

### 2.9 assign()： ###

具体和vector中的操作类似，也是有两种情况，第一种是：l1.assign(n,val)将 l1中元素变为n个T(val）。第二种情况是：l1.assign(l2.begin(),l2.end())将l2中的从l2.begin()到l2.end()之间的数值赋值给l1。

### 2.10 swap()： ###

交换两个链表(两个重载)，一个是l1.swap(l2); 另外一个是swap(l1,l2)，都可能完成连个链表的交换。

### 2.11 reverse()： ###

通过reverse()完成list的逆置。

### 2.12 merge()： ###

合并两个链表并使之默认升序(也可改)，l1.merge(l2，greater()); 调用结束后l2变为空，l1中元素包含原来l1 和 l2中的元素，并且排好序，升序。其实默认是升序，greater()可以省略，另外greater()是可以变的，也可以不按升序排列。

### splice方法 ###

就是将list的元素进行拼接，原理就是改变结点指针的指向，效率比较高。

先看看这splice方法的三种声明：  
（1）void splice ( iterator position, list<T,Allocator>& x );  
功能: 将 list x 中的元素全都移到position处  
（2）void splice ( iterator position, list<T,Allocator>& x, iterator it );  
功能: 将 list x 中的由迭代器it指向的元素移到position处  
（3）void splice ( iterator position, list<T,Allocator>& x, iterator first, iterator last );  
功能：将 list x 中的从迭代器 first 到迭代器 last 这一段元素移动到position处

注意：position位置的指定只能是调用者容器中的位置，要剪切的元素是list x中元素  
————————————————  
版权声明：本文为CSDN博主「beyond559」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/qq\_41909314/article/details/90575034