c++STL各个容器使用介绍

---

前言

  这人呀，年纪一到脑子就不够用了，每次使用STL中的一些函数时，大概有些映像，但是就是不能具体想出函数名称是啥或者具体参数是啥，百度大法虽然好但是着实影响效率，今天我就整理一下STL中的常用容器和常用函数用法，一篇博文基本解决STL的常用用法。

一、容器

1.序列式容器

1.1 字符串（string）

  字符串包括字符操作再leetcode刷题中经常遇到，是处理一些问题的基础，需要重点掌握。
string初始化：https://blog.youkuaiyun.com/VariatioZbw/article/details/116592225

1.1.1 将string转换为char*

方法1：使用c_str()方法
  代码如下：

#include <string>
#include <iostream>
#include <stdio.h>
 
using namespace std;
 
int main()
{
    string strOutput = "Hello World";
 
    cout << "[cout] strOutput is: " << strOutput << endl;
 
    // string 转换为 char*
    const char* pszOutput = strOutput.c_str();
    
    printf("[printf] strOutput is: %s\n", pszOutput);
 
    return 0;
}

编译并执行上述代码，结果如下：

上述代码执行结果说明：

• cout 可直接输出 string 类的对象的内容；
• 使用 c_str() 方法转换 string 类型到 char* 类型时，需要为char*添加 const 关键字；
• printf() 函数不能直接打印 string 类的对象的内容，可以通过将 string 转换为 char* 类型，再使用 printf() 函数打印。
  方法2：使用data()方法

data()方法与c_str()方法相似，都返回 const char* 类型。两者区别和联系如下：

• 在C++98版本中，c_str()返回 const char* 类型，返回的字符串会以空字符（null character）结尾；
• 在C++98版本中，data()返回 const char* 类型，返回的字符串不以空字符（null character）结尾；
• 在C++11版本中，c_str()与data()用法相同（Both string::data and string::c_str are synonyms and return the same value.）

注意:使用atoi() 和 atof()时需要先将string转化为const char*格式，即利用c_str()先转为const char *，然后再使用atoi()将字符串转化为int型数，或使用atof转化为float型数

1.1.2 常见函数

s.size()  // 求长度
s.empty()  // 判断是否为空

s.insert(int index, string str) // 在s[4]的位置插入str
// 举例说明
string s = "I am";
s.insert(4," good");  // 此时s为 I am good

s.substr(int pos,int length) // 从位置pose处开始，截取长度为length的子串

1.1.3 string中的find操作

find
注：学会find操作即可
注意:学会find操作就可以了，其他的不用理会，int find(char c,int pos = 0) const : 默认是从0位置开始找，没有找到返回npos这个关键字，其他的方法不用了解，用不到！！！

// string 中find方法
//从pos开始查找字符c在当前字符串的位置
int find(char c, int pos = 0) const;

//从pos开始查找字符串s在当前串中的位置
int find(const char *s, int pos = 0) const;

//从pos开始查找字符串s中前n个字符在当前串中的位置
int find(const char *s, int pos, int n) const;

//从pos开始查找字符串s在当前串中的位置
int find(const string &s, int pos = 0) const;

//以上查找成功时返回所在位置，失败返回string::npos的值

rfind

// string中的rfind函数
//从pos开始从后向前查找字符c在当前串中的位置
int rfind(char c, int pos = npos) const;
int rfind(const char *s, int pos = npos) const;
int rfind(const char *s, int pos, int n = npos) const;
int rfind(const string &s,int pos = npos) const;

//从pos开始从后向前查找字符串s中前n个字符组成的字符串在当前串中的位置，成功返回所在位置，失败时返回string::npos的值

还有一些其他的查找功能，详见https://blog.youkuaiyun.com/u014203453/article/details/77740423

1.1.4 将char*、char[]转化为string

将 char*、char[] 转换为 string 类型时，直接进行赋值操作，将 char*、char[] 的变量赋值给 string 对象即可。

说明：这里所说的“赋值”操作，实际上是将 char*、char[] 定义的字符串的首地址赋值给 string 对象了。

示例代码（stringtochar.cpp）如下：

#include <string>
#include <iostream>
 
using namespace std;
 
int main()
{
    const char* pszName = "liitdar";
    char pszCamp[] = "alliance";
 
    string strName;
    string strCamp;
 
    strName = pszName;
    strCamp = pszCamp;
 
    cout << "strName is: " << strName << endl;
    cout << "strCamp is: " << strCamp << endl;
 
    return 0;
}

1.1.4.2 单独的一个字符串与string类型的转化

1.
char c = 'a';
string str = {c};

2.
char c = 'a';
string str;
str.push_back(c);

不存在 字符类型 char到string类型的强制类型转化，即 string©会报错。

1.1.5 char型与整型的相互转化

首先需要注意的一点是将char型转化为整型不能直接通过int()强制类型转化，否则的话会转化为对应ascii码值，如下所示：

int main()
{
	// char 转为 int
	char a_c = '0';
	int a = int(a_c);
	int b = a_c - '0';
	cout << a << endl;
	cout << b << endl;

	// int 转为 char
	char b_c = b + '0';
	cout << b_c << endl;

	return 0;

}

结果如下：

可以知道 a_c - ‘0’ 才是正确的。

1.2 vector

1.2.1 vector常见函数

注意:erase的用法需要注意，里面的参数必须是迭代器，如arr.erase(arr.begin()+i)，或者先用auto iter = find(arr.begin(),arr.end(),num) ,然后删除：arr.erase(iter)

int size() ： 返回容器对象中元素的个数
bool empty(): 判断容器对象是否为空

begin()：返回指向容器中第一个元素的迭代器。

end()：返回指向容器中最后一个元素后面的位置的迭代器。

rbegin()：返回指向容器中最后一个元素的反向迭代器。

rend()：返回指向容器中第一个元素前面的位置的反向迭代器。

erase(iterator loc): 删除loc位置的元素(https://img2018.cnblogs.com/blog/1169804/201903/1169804-20190310230711138-1115905688.png)
erase(iterator first,iterator last): 删除[first,last)这一段
***需要注意，在进行单个元素删除后，传入的迭代器指向不变，仍然指
向被删除元素的位置，而被删除元素之后的所有元素都向前移动一位，也
就是该迭代器实际上是指向了原来被删除元素的下一个元素***

clear()：从容器中删除所有元素。

front()：返回容器中第一个元素的引用。

back()：返回容器中最后一个元素的引用。

push_back()：在容器末尾增加新元素。

pop_back()：删除容器末尾的元素。

insert(iterator loc ,size_type num)：指定位置loc前面插入元素

// c++ 11新特性
emplace_back(): 对标push_back()
emplace() : 对标insert()

find(vec.begin(),vec.end(),N);  //在vec中查找N,返回迭代器
// 如果返回的是 vec.end() 说明没有找到，即数组中不存在这个数
// 此外如果需要使用二分查找则必须是已经排序的数组

1.3 list

  list也是顺序容器的一种，知识list底层是一个双向链表，使用list必须包含头文件list。双向链表的每个元素中都有一个指针指向后一个元素，也有一个指针指向前一个元素，如下图所示。

  当然，list的用法和vector很类似，也拥有顺序容器中的常用方法，需要注意的是**list不支持使用下标随机存取元素。
在 list 容器中，在已经定位到要增删元素的位置的情况下，增删元素能在常数时间内完成。如下图所示，在 ai 和 ai+1 之间插入一个元素，只需要修改 ai 和 ai+1 中的指针即可

1.3.1 list的相关函数

#include <list>

// 1.头尾的添加移除操作
list.push_back(elem); //在容器尾部加入一个元素
list.pop_back(); //删除容器中最后一个元素
list.push_front(elem); //在容器开头插入一个元素
list.pop_front(); //从容器开头移除第一个元素

// 2.数据存取
list.front(); //返回第一个元素。
list.back(); //返回最后一个元素。

// 3.与迭代器相关
list.begin(); //返回容器中第一个元素的迭代器。
list.end(); //返回容器中最后一个元素之后的迭代器。
list.rbegin(); //返回容器中倒数第一个元素的迭代器。
list.rend(); //返回容器中倒数最后一个元素的后面的迭代器。

// 4.带参构造（和vector类似）
list(beg,end); //构造函数将[beg, end)区间中的元素拷贝给本身。注意该区间是左闭右开的区间。
list(n,elem); //构造函数将n个elem拷贝给本身。
list(const list &lst); //拷贝构造函数

// 5.大小相关（和vector类似）
list.size(); //返回容器中元素的个数
list.empty(); //判断容器是否为空
list.resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
list.resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

// 6.插入元素(注意是迭代器)
list.insert(pos,elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置。
list.insert(pos,n,elem); //在pos位置插入n个elem数据，无返回值。
list.insert(pos,beg,end); //在pos位置插入[beg,end)区间的数据，无返回值。

// 7.删除元素
list.clear(); //移除容器的所有数据
list.erase(beg,end); //删除[beg,end)区间的数据，返回下一个数据的位置。
list.erase(pos); //删除pos位置的数据，返回下一个数据的位置。
lst.remove(elem); //删除容器中所有与elem值匹配的元素。

// 8.反序排列
lst.reverse(); //反转链表

// 9.赋值操作
赋值操作
list.assign(beg,end); //将[beg, end)区间中的数据拷贝赋值给本身。注意该区间是左闭右开的区间。
list.assign(n,elem); //将n个elem拷贝赋值给本身。
list& operator=(const list &lst); //重载等号操作符
list.swap(lst); //将lst与本身的元素互换。

// 10.排序
sort(): // 排序，注意和vector的区别
// STL中的算法sort可以对vector和deque进行排序，它需要随机访问迭代器的支持，因为list不支持随机访问迭代器，所以不能用sort对list进行排序，因此list容器引入了sort成员函数以完成排序，

其他成员函数：

1.3.2 list的元素访问

  不同于之前学过的 STL 容器，访问 list 容器中存储元素的方式很有限，即要么使用 front() 和 back() 成员函数，要么使用 list 容器迭代器。

list 容器不支持随机访问，未提供下标操作符 [] 和 at() 成员函数，也没有提供 data() 成员函数。

通过 front() 和 back() 成员函数，可以分别获得 list 容器中第一个元素和最后一个元素的引用形式。举个例子：

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

int main()
{
    std::list<int> mylist{ 1,2,3,4 };
    int &first = mylist.front();
    int &last = mylist.back();
    cout << first << " " << last << endl;
    first = 10;
    last = 20;
    cout << mylist.front() << " " << mylist.back() << endl;
    return 0;
}

#include <iostream>
#include <list>
using namespace std;
int main()
{
    const std::list<int> mylist{1,2,3,4,5};
    auto it = mylist.begin();
    cout << *it << " ";
    ++it;
    while (it!=mylist.end())
    {
        cout << *it << " ";
        ++it;  
    }
    return 0;
}

1.4 deque

deque是双端队列，deque容器为一个给定类型的元素进行线性处理，像向量一样，它能够快速地随机访问任一个元素，并且能够高效地插入和删除容器的尾部元素。但它又与vector不同，deque支持高效插入和删除容器的头部元素，因此也叫做双端队列。deque类常用的函数如下。

deque():创建一个空deque

deque(int nSize):创建一个deque,元素个数为nSize

deque(int nSize,const T& t):创建一个deque,元素个数为nSize,且值均为t

deque(const deque &):复制构造函数

增加数

void push_front(const T& x):双端队列头部增加一个元素X

void push_back(const T& x):双端队列尾部增加一个元素x

iterator insert(iterator it,const T& x):双端队列中某一元素前增加一个元素x

void insert(iterator it,int n,const T& x):双端队列中某一元素前增加n个相同的元素x

void insert(iterator it,const_iterator first,const_iterator last):双端队列中某一元素前插入另一个相同类型向量的[first,last)间的数据

删除数

Iterator erase(iterator it):删除双端队列中的某一个元素

Iterator erase(iterator first,iterator last):删除双端队列中[first,last）中的元素

void pop_front():删除双端队列中最前一个元素

void pop_back():删除双端队列中最后一个元素

void clear():清空双端队列中所有元素

reference at(int pos):返回pos位置元素的引用

reference front():返回首元素的引用

reference back():返回尾元素的引用

iterator begin():返回向量头指针，指向第一个元素

iterator end():返回指向向量中最后一个元素下一个元素的指针（不包含在向量中）

reverse_iterator rbegin():反向迭代器，指向最后一个元素

reverse_iterator rend():反向迭代器，指向第一个元素的前一个元素

1.5 stack

很简单，没什么好说的，参考链接： https://blog.youkuaiyun.com/summer00072/article/details/80753821

C++ Stack（堆栈） 是一个容器类的改编，为程序员提供了堆栈的全部功能，——也就是说实现了一个先进后出（FILO）的数据结构。

c++ stl栈stack的头文件为: 

#include <stack> 

c++ stl栈stack的成员函数介绍

操作 比较和分配堆栈

empty() 堆栈为空则返回真

pop() 移除栈顶元素

push() 在栈顶增加元素

size() 返回栈中元素数目

top() 返回栈顶元素

1.6 queue

也很简单，

queue入队，如例：q.push(x); 将x 接到队列的末端。

queue出队，如例：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。

访问queue队首元素，如例：q.front()，即最早被压入队列的元素。// 不是用的top，而是front

访问queue队尾元素，如例：q.back()，即最后被压入队列的元素。

判断queue队列空，如例：q.empty()，当队列空时，返回true。

访问队列中的元素个数，如例：q.size()

1.7 heap

1.heap概述

  heap处于头文件#include<algorithm>中，STL在<algorithm.h>中实现了对存储在数组或者vector中（是的，没错，堆的底层是vector，堆是基于vector的特殊的数据结构）的元素进行堆操作的函数，包括make_heap，pop_heap，push_heap，sort_heap。
  默认情况下是max-heap，该大顶堆实际上是以一个vector表现的完全二叉树。

2.heap函数介绍

算了，队自己写吧，别看这些了。

// heap操作得四个函数
make_heap(_First,_Last,_Comp) ： 建立堆(要么大顶堆，要么就是小顶堆)
push_heap(_First,_Last,_Comp) : 在堆中添加元素
pop_heap(_First,_Last,_Comp) : 在堆中删除元素
sort_heap(_First,_Last,_Comp) : 堆排序
相关参数介绍：
 _First , _Last : 可以随机访问的迭代器/指针
 _Comp : 比较函数(仿函数)，其规则是：如果函数的第一个参数小于第二个参数应返回true,否则返回false,默认为less
以数据类型为int为例：若使用大顶堆，则_Comp为 less<int>()  , 小顶堆则为 greater<int>()

下面举例说明：
建立堆：

vector<int> min= {10,30,22,6,15,9};
//建立小顶堆
make_heap(min.begin(), min.end(), greater<int>()); //此时min中数据顺序如下：6 10 9 30 15 22

// 插入元素
min.push_back(20);
push_heap(min.begin(),min.end(), greater<int>());//该算法前提：必须在堆的条件下
// 此时 min:6 10 9 30 15 22 20 仍为小顶堆

// 删除堆顶元素
pop_heap(min.begin(),min.end(),greater<int>());
//此时min:9 10 20 30 15 22 6  不为小顶堆 这个pop_heap操作后，实际上是把堆顶元素放到了末尾
min.pop_back();  // 这才彻底在底层vector数据容器中删除堆顶元素
// 此时 min:9 10 20 30 15 22  仍为小顶堆

// 堆排序，保持greater,小顶堆，得到的是降序
sort_heap(min.begin(),min.end(), greater<int>());//试了用less，结果杂乱无章
//min:30 22 20 15 10 9 注意结果是降序的哦!!!其实是调用了很多次pop_heap(...,greater..)，每一次都把小顶堆堆顶的元素往末尾放，没放一次end迭代器减1

// 建立大顶堆的例子类时，将greater<int>()换成less<int>()即可

1.7 priority_queue

常用函数

  需要注意的一点是，priority_queue的基本函数和queue基本一致，唯一的区别是queue有front()和back() 函数 ，但是priority_queue只有top()，也只能pop()出队列顶端元素。

2.关联式容器

  标准的关联式容器分为set(集合)和map(映射表)，以及这两大类的衍生体multiset(多键集合)和multimap(多键映射表)，这些容器的底层机制均以 RB-TREE (红黑树)完成。

2.1 set

   set和map容器不同，使用 set 容器存储的各个键值对，要求键 key 和值 value 必须相等。当使用 set 容器存储键值对时，只需要为其提供各键值对中的 value 值（也就是 key 的值）即可。
使用 set 容器存储的各个元素的值必须各不相同。
STL中的set底层也是RB-TREE(红黑树)，集合中的每一个元素只出现一次，并且是排好顺序的（默认按照键值升序排列），访问元素的时间复杂度是O(log2 n)

在c++中，set的头文件是 #include<set>

set具有迭代器 set<int>::iterator i 定义一个迭代器,名为i 可以把迭代器理解为C语言的指针
set常用操作

set<int> q;     //以int型为例 默认按键值升序
set<int,greater<int>> p;  //降序排列 ，默认是升序排列
int x;
q.insert(x);	//将x插入q中
q.erase(x);		//删除q中的x元素,返回0或1,0表示set中不存在x
q.clear();		//清空q
q.empty();		//判断q是否为空，若是返回1，否则返回0
q.size();		//返回q中元素的个数
q.find(x);		//在q中查找x，返回x的迭代器，若x不存在，则返回指向q尾部的迭代器即 q.end()
q.lower_bound(x); //返回一个迭代器，指向第一个键值不小于x的元素
q.upper_bound(x); //返回一个迭代器，指向第一个键值大于x的元素

q.rend();		  //返回第一个元素的的前一个元素迭代器
q.begin();		  //返回指向q中第一个元素的迭代器

q.end();		 //返回指向q最后一个元素下一个位置的迭代器
q.rbegin();		 //返回最后一个元素

set单元素应用

#include<iostream>
#include<set>
using namespace std;
int main()
{
	set<int> q;   //默认按升序排列 
	q.insert(5);
	q.insert(5);
	q.insert(5);
	cout<<"q.size "<<q.size()<<endl;   //输出 1 ,在set插入中相同元素只会存在一个
	
	q.clear(); //清空set
	cout<<"q.size "<<q.size()<<"\n\n";
	
	q.insert(4);
	q.insert(4);
	q.insert(3);
	q.insert(3); 
	q.insert(2);
	q.insert(1);
	
	cout<<"lower_bound "<<*q.lower_bound(3)<<endl;  //返回3 
	cout<<"upper_bound "<<*q.upper_bound(3)<<"\n\n";  //返回4 
	
	set<int>::iterator i;
	for( i=q.begin();i!=q.end();i++)   //set的遍历 
		cout<<*i<<" ";				   //输出1 2 3 4，可见自动按键值排序 
	cout<<endl;
	
	q.erase(4);  //删除q中的 4 
	
	for(i=q.begin();i!=q.end();i++)  //再次遍历set 只输出 1 2 3 
		cout<<*i<<" ";
	cout<<"\n\n"; 
	
	
	set<int,greater<int>> p;  //降序排列 
	p.insert(1);
	p.insert(2);
	p.insert(3);
	p.insert(4);
	p.insert(5);
	for(i=p.begin();i!=p.end();i++)
		cout<<*i<<" ";
	cout<<endl;
	
	return 0;
}

set多元素应用(结构体)

#include<iostream>
#include<set>
using namespace std;
struct node{
	int a,b;
	bool operator< (const node W)const
	{
		return a>W.a;  //按a的值升序 
	}
}t;
int main()
{
	set<node> q;
	t.a=1;
	t.b=2;
	q.insert(t);
	
	t.a=4;
	t.b=2;
	q.insert(t);
	
	t.a=3;
	t.b=5;
	q.insert(t);	
	
	set<node>::iterator i;
	for(i=q.begin();i!=q.end();i++)
	{
		t=*i;
		cout<<t.a<<" "<<t.b<<endl;
	}
	return 0; 
}

 emsp;此外 STL还提供了unordered_set , unordered_set基于哈希表，数据插入和查找的时间复杂度很低，几乎是常数时间，而代价是消耗比较多的内存，无自动排序功能。底层实现上，使用一个下标范围比较大的数组来存储元素，形成很多的桶，利用hash函数对key进行映射到不同区域进行保存。
set与unordered相比：

1、set比unordered_set使用更少的内存来存储相同数量的元素。

2、对于少量的元素，在set中查找可能比在unordered_set中查找更快。

3、尽管许多操作在unordered_set的平均情况下更快，但通常需要保证set在最坏情况下有更好的复杂度(例如insert)。

4、如果您想按顺序访问元素，那么set对元素进行排序的功能是很有用的。

5、您可以用<、<=、>和>=从字典顺序上比较不同的set集。unordered_set集则不支持这些操作。

一般来说，在如下情况，适合使用set：

1、我们需要有序的数据(不同元素)。

2、我们必须打印/访问数据(按排序顺序)。

3、我们需要知道元素的前任/继承者。

一般来说，在如下情况，适合使用unordered_set：

1、我们需要保留一组元素，不需要排序。

2、我们需要单元素访问，即不需要遍历。

3、仅仅只是插入、删除、查找的话。

2.2 map

  现在有两类容器：map和unordered_map，对于多数应用到哈希表查找问题，采用unordered_map效率会高一些。下面对这二者的区别和联系做一个介绍。map的底层用的是红黑树，其是有序的，unordered_map的底层是哈希表，是无序的，整体而言map占用的内存更多但是查找的效率较低，而unordered_map占用的内存更高，但是由于底层是哈希表其查找的效率会高不少。

二、算法

sort(arr.begin(),arr.end(),greater()) // 降序排列
sort(arr.begin(),arr.end(),less()) // 升序排列
其他的百度即可，感觉用的不多，堆以及堆排的相关函数前面介绍了。

三、适配器

待更新！！！

参考文献

[1]. 侯捷，STL源码解析
[2] https://blog.youkuaiyun.com/u013317445/article/details/89680330
[3] https://blog.youkuaiyun.com/liitdar/article/details/80498634