vector初始化

  1. vector<int> v; //定义一个空 vector 对象
  2. vector<int> v(10); //定义一个具有 10 个元素的 vector 对象（int 型元素默认初始化为 0）
  3. vector<int> v(3,5); //v = { 5, 5, 5 }
  4. vector<int> v1(v); //v1 = v
  5. vector<int> v = { 1, 2, 3 };
  6. vector<int> v1 = v;
  8. set<char> s { 'a', 'b', 'c' };
  9. vector<int> v (s.begin(), s.end()); // v = { 97, 98 , 99}
  10. vector<string>({ret.begin(), ret.end()});
  11. v.insert(it, num);

字符串和数字之间的转换

c++之to_string()函数

函数原型：

  1. string to_string (int val);
  2. string to_string (long val);
  3. string to_string (long long val);
  4. string to_string (unsigned val);
  5. string to_string (unsigned long val);
  6. string to_string (unsigned long long val);
  7. string to_string (float val);
  8. string to_string (double val);
  9. string to_string (long double val);

功能：
将数值转化为字符串。返回对应的字符串。

字符串转换

  1. #include <stdlib.h>
  2. atoi() 函数用来将字符串转换成整数(int)
  3. atol() 函数用来将字符串转换成整数(long)
  4. atof() 用于将字符串转换为双精度浮点数(double)
  5. strtod() 用来将字符串转换成双精度浮点数(double)
  6. strtol() 函数用来将字符串转换为长整型数(long)
  7. strtoul() 函数源自于“string to unsigned long”，用来将字符串转换成无符号长整型数(unsigned long)

迭代器

  1. vector<int>::iterator i;  //定义正向迭代器
  2. vector<int>::reverse_iterator i;  //定义反向迭代器

stack

  1. #include<stack>
  3. stack<int> s;
  4. stack< int, vector<int> > stk;  //覆盖基础容器类型，使用vector实现stk
  5. s.empty();  //判断stack是否为空，为空返回true，否则返回false
  6. s.size();   //返回stack中元素的个数
  7. s.pop();    //删除栈顶元素，(但不返回其值)
  8. s.top();    //返回栈顶元素的值，但不删除此元素
  9. s.push(item);   //在栈顶压入新元素item

queue

  1. #include<stack>
  3. queue<int> q; //priority_queue<int> q;
  4. q.empty();  //判断队列是否为空
  5. q.size();   //返回队列长度
  6. q.push(item);   //对于queue，在队尾压入一个新元素
  7. q.pop()         //弹出第一个元素，无返回值
  9. //queue only:
  10. q.front();  //返回队首元素的值(也就是第一个被置入的元素)，但不删除该元素
  11. q.back();   //返回队尾元素的值(也就是最后一个被置入的元素)，但不删除该元素
  13. //priority_queue only:
  14. q.top();    //返回具有最高优先级的元素值，但不删除该元素
  16. deq.begin();//开始迭代器指针
  17. deq.end();    //末尾迭代器指针

image.png

priority_queue

  1. priority_queue<int> q;
  2. q.empty();      //判断队列是否为空
  3. q.size();       //返回队列长度
  4. q.push(item);     //在基于优先级的适当位置插入新元素
  5. q.pop()         //弹出优先级最低的元素，没有返回值
  6. q.top();        //返回具有最高优先级的元素值，但不删除该元素
  8. //升序队列，小顶堆
  9. priority_queue <int,vector<int>,greater<int> > q;
  10. //降序队列，大顶堆
  11. priority_queue <int,vector<int>,less<int> >q;
  12. //对于基础类型 默认是大顶堆
  13. priority_queue<int> q;

deque

  1. deq.size();            //容器大小
  2. deq.empty();        //容器判空
  3. deq.push_front(x);    //头部添加元素
  4. deq.push_back(x);    //末尾添加元素
  5. deq.insert(iterator it, const T& x);    //任意位置插入一个元素
  6. deq.insert(iterator it, int n, const T& x);    //任意位置插入 n 个相同元素
  7. deq.insert(iterator it, iterator first, iterator last);    //插入另一个向量的 [forst,last] 间的数据
  8. deq.pop_front();    //头部删除元素
  9. deq.pop_back();        //末尾删除元素
  10. deq.erase(iterator it);    //任意位置删除一个元素
  11. deq.erase(iterator first, iterator last);    //删除 [first,last] 之间的元素
  12. deq.clear();    //清空所有元素
  13. deq[1];            //下标访问
  14. deq.at(1);        //at 方法访问
  15. deq.front();    //访问第一个元素
  16. deq.back();        //问最后一个元素
  18. //遍历元素
  19. deque<int>::iterator it;
  20. for (it = deq.begin(); it != deq.end(); it++)
  21.     cout << *it << endl;
  22. // 或者
  23. for (int i = 0; i < deq.size(); i++) {
  24.     cout << deq.at(i) << endl;
  25. }
  1. #include <iostream>
  2. #include <deque>
  4. using namespace std;
  6. int main(int argc, char* argv[])
  7. {
  8.     deque<int> deq;
  10.     // 头部增加元素
  11.     deq.push_front(4);
  12.     // 末尾添加元素
  13.     deq.push_back(5);
  14.     // 任意位置插入一个元素
  15.     deque<int>::iterator it = deq.begin();
  16.     deq.insert(it, 2);
  17.     // 任意位置插入n个相同元素
  18.     it = deq.begin(); // 必须要有这句
  19.     deq.insert(it, 3, 9);
  20.     // 插入另一个向量的[forst,last]间的数据
  21.     deque<int> deq2(5,8);
  22.     it = deq.begin(); // 必须要有这句
  23.     deq.insert(it, deq2.end() - 1, deq2.end());
  25.     // 遍历显示
  26.     for (it = deq.begin(); it != deq.end(); it++)
  27.         cout << *it << " "; // 输出：8 9 9 9 2 4 5
  28.     cout << endl;
  30.     return 0;
  31. }

image.png

reverse

  1. #include <algorithm>
  2. reverse(deq.begin(), deq.end());

元素排序

  1. #include <algorithm>
  2. sort(deq.begin(), deq.end()); // 采用的是从小到大的排序
  4. // 如果想从大到小排序，可以采用先排序后反转的方式，也可以采用下面方法:
  5. // 自定义从大到小的比较器，用来改变排序方式
  6. bool Comp(const int& a, const int& b) {
  7.     return a > b;
  8. }
  10. sort(deq.begin(), deq.end(), Comp);

遍历

  1. deque<int>::iterator it;
  2. for (it = deq.begin(); it != deq.end(); it++)
  3.     cout << *it << endl;
  4. // 或者
  5. for (int i = 0; i < deq.size(); i++) {
  6.     cout << deq.at(i) << endl;
  7. }

list

  1. #include <list>
  3. //list定义和初始化
  4. list<int>lst1;          //创建空list
  5. list<int> lst2(5);       //创建含有5个元素的list
  6. list<int>lst3(3,2);  //创建含有3个元素的list
  7. list<int>lst4(lst2);    //使用lst2初始化lst4
  8. list<int>lst5(lst2.begin(),lst2.end());  //同lst4
  11. //list常用操作函数
  12. Lst1.assign() 给list赋值 
  13. Lst1.back() 返回最后一个元素 
  14. Lst1.begin() 返回指向第一个元素的迭代器 
  15. Lst1.clear() 删除所有元素 
  16. Lst1.empty() 如果list是空的则返回true 
  17. Lst1.end() 返回末尾的迭代器 
  18. Lst1.erase() 删除一个元素 
  19. Lst1.front() 返回第一个元素 
  20. Lst1.get_allocator() 返回list的配置器 
  21. Lst1.insert() 插入一个元素到list中 
  22. Lst1.max_size() 返回list能容纳的最大元素数量 
  23. Lst1.merge() 合并两个list 
  24. Lst1.pop_back() 删除最后一个元素 
  25. Lst1.pop_front() 删除第一个元素 
  26. Lst1.push_back() 在list的末尾添加一个元素 
  27. Lst1.push_front() 在list的头部添加一个元素 
  28. Lst1.rbegin() 返回指向第一个元素的逆向迭代器 
  29. Lst1.remove() 从list删除元素 
  30. Lst1.remove_if() 按指定条件删除元素 
  31. Lst1.rend() 指向list末尾的逆向迭代器 
  32. Lst1.resize() 改变list的大小 
  33. Lst1.reverse() 把list的元素倒转 
  34. Lst1.size() 返回list中的元素个数 
  35. Lst1.sort() 给list排序 
  36. Lst1.splice() 合并两个list 
  37. Lst1.swap() 交换两个list 
  38. Lst1.unique() 删除list中相邻重复的元素

vector

  1. 1.push_back 在数组的最后添加一个数据
  2. 2.pop_back 去掉数组的最后一个数据
  3. 3.at 得到编号位置的数据
  4. 4.begin 得到数组头的指针
  5. 5.end 得到数组的最后一个单元+1的指针
  6. 6.front 得到数组头的引用
  7. 7.back 得到数组的最后一个单元的引用
  8. 8.max_size 得到vector最大可以是多大
  9. 9.capacity 当前vector分配的大小
  10. 10.size 当前使用数据的大小
  11. 11.resize 改变当前使用数据的大小，如果它比当前使用的大，者填充默认值
  12. 12.reserve 改变当前vecotr所分配空间的大小
  13. 13.erase 删除指针指向的数据项
  14. 14.clear 清空当前的vector
  15. 15.rbegin 将vector反转后的开始指针返回(其实就是原来的end-1)
  16. 16.rend 将vector反转构的结束指针返回(其实就是原来的begin-1)
  17. 17.empty 判断vector是否为空
  18. 18.swap 与另一个vector交换数据

map

map
map.find(key);//返回一个地址，可以用迭代器接收
mp[key] = value// 插入数据
iterator it= map.find(key);
map.count(key) // 统计key出现的次数,结果为0或者1
it.first为key
it.second为value

  1. map<int ,string>maplive;
  2. // 添加数据
  3. maplive.insert(pair<int,string>(102,"aclive"));
  4. maplive.insert(map<int,string>::value_type(321,"hai"));
  5. maplive[112]="April";//map中最简单最常用的插入添加！
  7. //元素的查找
  8. map<int ,string >::iteratorl_it;
  9. // 当key为x时
  10. l_it=maplive.find(x);//返回的是一个指针
  12. if(l_it==maplive.end())
  13.     cout<<"we do not find x"<<endl;
  14. else
  15.     cout<<"wo find x"<<endl;
  17. map<string,string>m;
  18. if(m[x]=="")
  19.     cout<<"we do not find x"<<endl;
  22. //元素的删除
  23. map<int ,string>::iterator l_it;;
  24. l_it =maplive.find(112);
  25. if( l_it == maplive.end())
  26.     cout<<"we do not find112"<<endl;
  27. else 
  28.     maplive.erase(l_it);//delete 112;

unordered_map：

优点： 因为内部实现了哈希表，因此其查找速度非常的快
缺点： 哈希表的建立比较耗费时间
适用处：对于查找问题，unordered_map会更加高效一些，因此遇到查找问题，常会考虑一下用unordered_map

set

在set中每个元素的值都唯一，而且系统能根据元素的值自动进行排序。set中元素的值不能直接被改变。set内部采用的是一种非常高效的平衡检索二叉树：红黑树，也称为RB树(Red-Black Tree)。RB树的统计性能要好于一般平衡二叉树。

  1. begin();            // 返回指向第一个元素的迭代器
  2. end();              // 返回指向迭代器的最末尾处（即最后一个元素的下一个位置）
  3. clear();            // 清除所有元素
  4. count();            // 返回某个值元素的个数
  6. empty();            // 如果集合为空，返回true
  8. equal_range();      //返回集合中与给定值相等的上下限的两个迭代器
  10. erase()–删除集合中的元素
  12. find()–返回一个指向被查找到元素的迭代器
  14. get_allocator()–返回集合的分配器
  16. insert()–在集合中插入元素
  18. lower_bound()–返回指向大于（或等于）某值的第一个元素的迭代器
  20. key_comp()–返回一个用于元素间值比较的函数
  22. max_size()–返回集合能容纳的元素的最大限值
  24. rbegin()–返回指向集合中最后一个元素的反向迭代器
  26. rend()–返回指向集合中第一个元素的反向迭代器
  28. size()–集合中元素的数目
  30. swap()–交换两个集合变量
  32. upper_bound()–返回大于某个值元素的迭代器
  34. value_comp()–返回一个用于比较元素间的值的函数

unordered_set(用哈希函数组织的set)；

unordered_multiset(哈希组织的set，关键字可以重复出现)。