• C++ 容器 详解

    目录

    STL：

    vector容器：

    string容器：

    deque容器：

    stack容器：(先进后出)

    queue容器：（先进先出）

    list容器：

    set/multiset容器：

    pair对组创建：

    map容器：

    STL：

    STL，即标准模板库，用着感觉和python差不多。

    STL 六大组件：容器（序例式和关联式） 算法（质变和非质变） 迭代器 仿函数 适配器 空间配置器。首先，我们来看以下Vector容器：

    vector容器：

    不同之处是数组是静态空间，而vector可以动态扩展。

    迭代器：随机访问迭代器

    1. vector.begin()指向第一个
    2. vector.end()指向最后一个元素的后面一个
    3. vector.rbegin()指向倒数第一个元素
    4. vector.rend()指向第一个元素的前一个


    容器嵌套:

    vector<vector<int>>


    构造：

    1. vector<int>v1;
    2. vector<int>v2(v1.begin(),v1.end())
    3. vector<int>v3(10,100)


    赋值：

    1. 直接等号赋值
    2. vector.assign(10,100)
    3. vector.assign(begin,end)


    容量和大小：

    1. empty()
    2. capacity()
    3. size()
    4. resize(num)
    5. resize(num,elem)elem为填充元素


    插入和删除：

    1. push_back() 尾部添加元素
    2. pop_back()删除尾部元素
    3. insert(迭代器pose，elem)
    4. insert(迭代器pose，n,elem)插入n个
    5. erase(迭代器pose)删除索引位置
    6. erase（v.begin(),v.end()）区间删除
    7. clear()清空


    数据存取：

    1. at(int dex)返回索引为idx的元素
    2. operator[]返回索引为idx的元素，如v[idx]
    3. front()返回容器中第一个数据元素
    4. back()返回容器中最后一个数据元素


    互换容器：

    swap(v)


    实际用途：收缩占用空间 vector<int>(v).swap(v),创建匿名对象进行互换，达到收缩空间的效果
    预留空间：
     

    reserve(len) 容器预留len个元素长度，不进行初始化，不可访问，而resize（）则被初始化为0

    string容器：

    string拼接函数：

    1.  
    2. string.append(str,n)截取前n个元素进行拼接
    3. string.append(str,start,n)可以选择从第n个截取


    string查找和替换：

    1. string.find(str)返回查找子字符串中第一个元素的索引，没有返回-1
    2. string.rfind(str)区别在于rfind从右往左查
    3. string.replace(start,n,str)从start开始的n个字符替换为str


    字符串比较（ASCII码值逐个比较）：

    string.compare(str)大于返回1，等于返回0，小于返回-1


    字符串存取：

    string[i],string.at(i)可以修改或访问第i个元素


    字符串插入和删除：

    string.insert(n,str) str.erase(i,n)删除从i开始的n个字符


    求子串操作：
     

    string.substr(start,n)

    deque容器：

    构造：

    1. deque<int>d1;
    2. deque<int>d2(d1.begin(),d1.end());
    3. deque<int>d3(10,100);
    4. deque<int>d4(d3);


    赋值操作：

    1. deque<int>d2=d1;
    2. deque<int>d3.assign(d1.begin(),d1.end());
    3. deque<int>d4.assign(10,100)


    大小操作：

    1. deque.empty()
    2. deque.size()
    3. deque.resize(size)
    4. deque.resize(size,elem)


    插入和删除;

    1. deque.push_back()尾插
    2. deque.push_front()头插
    3. deque.pop_back()尾删
    4. deque.pop_front()头删
    5. deque.erase(迭代器pose)
    6. deque.insert(deque.begin(),elem)
    7. deque.insert(deque.begin(),num,elem)
    8. deque.insert(deque.begin(),d2.begin(),d2.end())
    9. deque.erase（deque.begin(),deque.end()）
    10. deque.clear()清空


    数据存取：

    1. at(int dex)返回索引为idx的元素
    2. operator[]返回索引为idx的元素，如deque[idx]
    3. front()返回容器中第一个数据元素
    4. back()返回容器中最后一个数据元素


    排序：
     

    sort(iterator begin,iterator end)默认升序，对于支持随即访问迭代器的容器，都可以直接使用该算法进行排序
    1. #include<iostream>
    2. #include<vector>
    3. #include<algorithm>
    4. #include<deque>
    5. using namespace std;
    6. void printdeq(const deque<int >&d)
    7. {
    8.     for (deque<int>::const_iterator it=d.begin();it<d.end();it++)
    9.     {
    10.         cout<<*it<<" ";
    11.     }
    12.     cout<<endl;
    13. }
    14. void test()
    15. {
    16.     deque<int>d;
    17.     d.push_back(1);
    18.     d.push_back(3);
    19.     d.push_back(2);
    20.     sort(d.begin(),d.end());
    21.     printdeq(d);
    22.  
    23. }
    24.  
    25.  
    26. int main()
    27. {
    28.     test();
    29. }

     

    stack容器：(先进后出)

    构造：

    stack<int>s;


    插入和删除：
     

    1. stack.push()插入
    2. stack.pop()删除
    3. stack.empty()判断是否为空
    4. stack.size()大小
    5. s.top()栈顶元素

    queue容器：（先进先出）

    1. queue.push()插入
    2. queue.pop()删除
    3. queue.empty()判断是否为空
    4. queue.size()大小
    5. queue.front()队头元素
    6. queue.back()队尾元素

     

    list容器：

    链表由一个个结点（数据域+指针域）构成，与数组相比可以快速添加或者和删除元素，但是遍历速度没有数组快，而且占用空间比数组要大。STL链表是双向循环链表。
    迭代器属于双向迭代器，不支持随机访问，而且进行插入和删除操作时，原有迭代器不会失效。
    构造函数：

    1. list<int>l1;
    2. list<int>l2(l1.begin(),l1.end())
    3. list<int>l3(num,elem)
    4. list<int>l4(l3)


    赋值和交换：

    1. list.assign(beg,end)
    2. list.assign(num,elem)
    3. =赋值，如l1=l2
    4. l1.swap(l2)交换


    大小操作：

    1. list.size()
    2. list.empty()
    3. list.resize(size)
    4. list.resize(size,elem)


    插入和删除：

    1. push_back(elem)尾插
    2. pop_back()尾删
    3. push_front(elem)头插
    4. pop_front()头删
    5. insert(pose,elem) pose(迭代器)处插入元素
    6. insert(pose,n,elem)插入n个元素
    7. insert(pose,beg,end)区间插入，从pose开始
    8. clear()清空
    9. erase(pose)删除pose处的元素
    10. erase(beg,end)删除区间元素
    11. remove(elem)移除elem元素


    数据存取：
     

    1. list.front()返回首元素
    2. list.back()返回尾部元素
    3. 反转和排序：
    4. list.reverse()反转
    5. list.sort()排序,默认升序,若需要降序，则需要加仿函数
    1. //list降序升序排列
    2. #include <iostream>
    3. #include <list>
    4. using namespace std;
    5.  
    6. void printlist(list<int>&l)
    7. {
    8.     for(list<int>::iterator it=l.begin();it!=l.end();it++)
    9.     {
    10.         cout<<*it<<" ";
    11.     }
    12.     cout<<endl;
    13. }
    14. bool compare(int val1,int val2)
    15. {
    16.     return val1>val2;
    17. }
    18. void test()
    19. {
    20.     list<int>l;
    21.  
    22.         l.push_back(40);
    23.         l.push_back(60);
    24.         l.push_back(430);
    25.         l.push_back(0);
    26.         l.push_back(5);
    27.         l.push_back(4);
    28.         cout<<"排序前： "<<endl;
    29.         printlist(l);
    30.         l.sort();
    31.         cout<<"升序排列： "<<endl;
    32.         printlist(l);
    33.         cout<<"降序排列： "<<endl;
    34.         l.sort(compare);
    35.         printlist(l);
    36. }
    37.  
    38. int main()
    39. {
    40.     test();
    41.     return 0;
    42. }

     

    1. //自定义类型排序
    2. #include<iostream>
    3. #include <list>
    4. using namespace std;
    5. class Person
    6. {
    7.     public:
    8.     string name;
    9.     int age;
    10.     int height;
    11.     Person(string na,int a,int b)
    12.     {
    13.         name=na;
    14.         age=a;
    15.         height=b;
    16.     }
    17. };
    18. void setperson(list<Person>&l)
    19. {
    20.     Person p1("A",17,175);
    21.     Person p2("B",18,172);
    22.     Person p3("C",17,175);
    23.     Person p4("D",18,168);
    24.     Person p5("E",17,170);
    25.     l.push_back(p1);
    26.     l.push_back(p2);
    27.     l.push_back(p3);
    28.     l.push_back(p4);
    29.     l.push_back(p5);
    30. }
    31. bool mycompare(Person p1,Person p2)
    32. {
    33.     if(p1.age==p2.age)
    34.     {
    35.         return p1.height<p2.height;
    36.     }
    37.     else
    38.     return p1.age<p2.age;
    39. }
    40. void printperson(list<Person>l)
    41. {
    42.     for(list<Person>::iterator it=l.begin();it!=l.end();it++)
    43.     {
    44.         cout<<"姓名： "<<it->name<<"  age: "<<(*it).age<<"  height: "<<it->height<<endl;
    45.     }
    46. }
    47. int main()
    48. {
    49.  
    50.     list<Person>l;
    51.     setperson(l);
    52.     cout<<"排序前:"<<endl;
    53.     printperson(l);
    54.     l.sort(mycompare);
    55.     cout<<"排序后:"<<endl;
    56.     printperson(l);
    57.  
    58.     return 0;
    59. }

     

    set/multiset容器：

    所有元素在插入时自动被排序，属于关联式容器，底层结构为二叉树
    set与multiset区别：set不允许有重复元素，而multiset可以
    构造和赋值：

    1. set<int>s1
    2. set<int>s2(s1)
    3. =赋值
    4. 插入：只有insert方式
    5. set.insert(elem)注意：若要是插入后元素是降序排列，则要使用仿函数作为排列规则


    大小和交换：

    1. set.size()
    2. set.empty()
    3. set.swap(l)


    插入和删除：

    1. set.insert(elem)
    2. set.clear()
    3. set.erase(pos)
    4. set.erase(betg,end)
    5. set.erase(elem)


    查找和统计：
     

    1. set.find(key)返回该元素的迭代器，若不存在，则fanhuiset.end()
    2. set.count(key)
    1. //利用仿函数指定创建时的排序规则
    2. #include<iostream>
    3. #include<string>
    4. #include<set>
    5. using namespace std;
    6. class Person
    7. {
    8. public:
    9. string name;
    10. int age;
    11. Person(string a,int b)
    12. {
    13.     this->name=a;
    14.     this->age=b;
    15. };
    16. };
    17.  
    18. class mycompare
    19. {
    20. public:
    21.    bool  operator()(const Person &p1,const Person &p2)
    22.     {
    23.         return p1.age>p2.age;
    24.     }
    25.  
    26. };
    27.  
    28. void printperson(set<Person,mycompare>s)
    29. {
    30.     for(set<Person,mycompare>::iterator it=s.begin();it!=s.end();it++)
    31.     {
    32.         cout<<it->name<<"  "<<(*it).age<<endl;
    33.     }
    34. }
    35.  
    36. void setperson()
    37. {
    38.     Person p1("A",13);
    39.     Person p2("B",12);
    40.     Person p3("C",16);
    41.     Person p4("D",10);
    42.     set<Person,mycompare>s;
    43.     cout<<"降序插入"<<endl;
    44.     s.insert(p1);
    45.     s.insert(p2);
    46.     s.insert(p3);
    47.     s.insert(p4);
    48.     printperson(s);
    49. }
    50.  
    51. int main()
    52. {
    53.     set<Person>p;
    54.     setperson();
    55.     return 0;
    56. }

     

    pair对组创建：

    1. 使用时不需要包含头文件
    2. pair<type,type> p(val1,val2)
    3. pair<type,type> p=make_pair(val1,val2)
    4. 获取：p.first p.second

    map容器：

    1.map中所有元素都是pair
    2.pair中第一个元素时键值key，起到索引作用，第二个元素为实值value
    3.所有元素会根据键值自动排序
    4.属于关联式容器，底层用二叉树实现
    map和multimap区别：
    1.map允许有重复key值元素
    2.multimap允许容器中有重复key值元素
    构造和赋值：

    1. map<int,int>m1;
    2. map<int,int>m2(m1);
    3. map<int,int>m3;m3=m2;


    大小和交换：

    1. map.size()
    2. m.empty()
    3. m.swap(m1)


    插入和删除：

    1. m.insert(elem)
    2. m.clear()
    3. m.erase(pose)
    4. m.erase(beg,end)
    5. m.erase(key)


    查找和统计：

    1. m.find(key)
    2. m.count(key)


    排序：可以利用仿函数指定排序规则

    1. #include<iostream>
    2. #include<string>
    3. #include<map>
    4. using namespace std;
    5.  
    6. class Mycompare
    7. {
    8.     public:
    9.     bool operator()(int v1,int v2)
    10.     {
    11.         return v1>v2;
    12.     }
    13. };
    14. void print1(map<int,int>&m)
    15. {
    16.     for(map<int,int>::iterator it=m.begin();it!=m.end();it++)
    17.     {
    18.         cout<<"key="<<it->first<<"value="<<it->second<<endl;
    19.     }
    20.     cout<<endl;
    21. }
    22. void test01()
    23. {
    24.     map<int,int>m;
    25.     m.insert(make_pair(1,10));
    26.     m.insert(make_pair(3,30));
    27.     m.insert(make_pair(2,20));
    28.     cout<<"升序"<<endl;
    29.     print1(m);
    30. }
    31. void print2(map<int,int,Mycompare>&m)
    32. {
    33.     for(map<int,int,Mycompare>::iterator it=m.begin();it!=m.end();it++)
    34.     {
    35.         cout<<"key="<<it->first<<"value="<<it->second<<endl;
    36.     }
    37.     cout<<endl;
    38. }
    39. void test02()
    40. {
    41.     map<int,int,Mycompare>m1;
    42.     m1.insert(make_pair(1,10));
    43.     m1.insert(make_pair(3,30));
    44.     m1.insert(make_pair(2,20));
    45.     cout<<"降序"<<endl;
    46.     print2(m1);
    47. }
    48. int main()
    49. {
    50.     test01();
    51.     test02();
    52.     return 0;
    53. }

     本文代码被本人不小心删除了大量例程，所以很多部分没有代码，若有不懂的小伙伴，欢迎讨论。

  • 相关阅读:
    在nodejs中使用typescript
    Nacos单机配置集群配置
    zookeeper集群搭建
    5147. 数量
    OpenGL 反色
    如何准确高效的对电商数据进行分析
    C/C++ 深入浅出C++模板（上）
    springboot实现转发和重定向
    计算机组成原理——存储器1-20
    axios添加缓存请求，防止多次请求，单页面多个同一组件造成多次请求解决方案
  • 原文地址：https://blog.csdn.net/wangcheng_BI/article/details/125405035