c++ 常用STL总结

---

---

vector（可随机访问）

vector数组是动态扩展，找更大的空间将原数据拷贝过来，释放原空间

构造

vector <int>ret_0;
	ret_0.push_back(1);
	show(ret_0);
	vector <int> ret(5);//不写第二位默认为0
	show(ret);
	vector <int> ret_1(5, 8);
	show(ret_1);
	vector <int> ret_2(ret_1.begin(), ret_1.end());
	show(ret_2);
	vector <int> ret_3(ret_2);
	show(ret_3);
1
2
3
4
5
6
7
8
9
10
11

二维vector

//一种三行四列方法
vector<vector<int>> ret(3,vector<int>(4, 1));
1
2

//另一种三行四列方法
vector <vector<int>>ret;
ret.resize(3);
ret[i].resize(4);
1
2
3
4

赋值操作[赋值用assign(5,10)]

	vector <int> ret_1(5, 8);
	show(ret_1);
	vector <int>ret;
	ret = ret_1;
	show(ret);
	vector <int>ret_0;
	ret_0.assign(10 ,5);
	show(ret_0);
1
2
3
4
5
6
7
8

容量和大小

ret.size()//返回的是大小
ret.caoacity();//返回的是容量
//注意容量>=大小
ret.resize(10);//指定长的大于原来的会补零，小于会截断
ret.empty();//为空1不为空0
1
2
3
4
5

插入和删除

ret.push_back(1);//插入数据（尾插） 1
ret.pop_back();//删除尾部
ret.insert(ret.begin(),30);//在begin[头部]插
ret.insert(ret.begin(),2,10);//在前面插入2个10
ret.erase(ret.begin());//删除头部数据
ret.erase(ret.begin(),ret.end());//删除从头到尾数据同下
ret.clear();//清空
1
2
3
4
5
6
7

数据存取(front|back)

//遍历方法一
for(int i=0;i<ret.size();i++)
	cout<<ret[i];
//遍历方法二
for(auto a: ret)
	cout<<a;
//获取第一个元素
cout<<ret.front();
//获取最后一个元素
cout<<ret.back();
1
2
3
4
5
6
7
8
9
10

容器互换(swap)

//两种方法均互换
ret1.swap(ret2);
swap(ret1,ret2);
1
2
3

可利用swap实现容量压缩

vector <int>(v).swap(v);//匿名对象(执行完后立即回收)
1

预留空间(reserve)

reserve(100);//预留100容量，不初始化数据所以不可访问
1

deque(双端数组)(可随机访问)

构造函数

deque <int> ret(10,100);//10个100
//把ret赋值给ret_1和ret_2
deque <int> ret_1(ret.begin(),ret.end());
deque <int> ret_2(ret);
1
2
3
4

赋值操作(同vector一致)

	deque <int> ret(5, 8);
	ret_1 = ret;//ret赋值给ret_1
	ret_2.assign(ret.begin(),ret.end());
	deque <int> ret_3;
	ret_3.assign(5,10);
1
2
3
4
5

大小（deque没有容量）

ret.empty();//为空1不为空0
ret.size();//返回大小
ret.resize(10);//设置大小为10[多出的覆盖为0]
ret.resize(10,5);//设置10个[多出的覆盖为5]
1
2
3
4

插入和删除

//插入
ret.push_back(1);//尾插数据1
ret.push_front(1);//头插数据1
//删除
ret.pop_back();//尾部数据删除
ret.pop_front();//头部数据删除
//指定位置插入
ret.insert(ret.begin,100);//头部插入数据100
ret.insert(ret.begin(),2,10);//头部插入2个数据10
//按照区间插入数据[在头部插入从头部到尾部的数据]
ret.insert(ret.begin(),ret.begin(),ret.end());
//删除
deque <int>iterator it =ret.begin();
it++;
ret.erase(it);//删除第二个元素
ret.erase(ret.begin+1);//删除第二个元素
ret.erase(ret.begin(),ret.end());//清空
ret.clear();//清空
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

数据存取（和vector一致）

for(int i=0;i<ret.size();i++)
cout<<ret.at(i);
//和两个for
cout<<ret.front();//访问第一个数据
cout<<ret.back();//访问最后一个
1
2
3
4
5

排序

sort(ret.begin(),ret.end());//升序
1

栈容器stack(不可随机访问)（先进后出不可遍历）

构造函数

	stack <int> ret;
	ret.push(1);
	cout << ret.top();
	stack <int> ret_1(ret);//拷贝构造
	cout << endl << ret_1.top();
1
2
3
4
5

其他接口

stack <int> ret;//先进后出数据结构
ret.push(1);//将数据1入栈
ret.pop();//将数据出栈
ret.top();//查看栈顶元素数据
ret.empty();//栈是否为空
ret.size();//栈的大小

1
2
3
4
5
6
7

队列容器queue(不可遍历不可随机访问)(先进先出，队头出队队尾入队)

构造函数

	queue <int> ret;
	ret.push(1);
	cout << ret.front();
	queue <int> ret_1(ret);//拷贝构造
	cout << endl << ret_1.front();
1
2
3
4
5

其他接口

ret.push(1);//将数据1入队 队尾入队
ret.pop();//出队 队头出队
ret.front();//查看对头数据
ret.back();//查看队尾数据
ret.size();//队大小
ret.empty();//队是否为空

1
2
3
4
5
6
7

链表list容器(不可随机访问)(双向循环链表)【常用】

可在任何位置插入和删除,但是遍历和查找慢

构造函数（同vector）

list <int> ret;
ret.push_back(1);//将数据1加入链表
list <int> ret1(ret);//拷贝构造
list <int> ret2(ret.begin(),ret.end());//区间构造
list <int> ret3(10,5);//设置10个数据5
1
2
3
4
5

赋值和交换

//赋值
list <int> ret(10,5);
list <int> ret1;
list <int> ret2;
ret1=ret;//ret赋值给ret1
ret2.assign(ret.begin(),ret.end());//ret赋值给ret2
ret3.assign(10,5);//设置10个数据5
//交换
swap(ret4,ret);//ret4和ret数据交换
1
2
3
4
5
6
7
8
9

大小操作

ret.size();//查看大小
ret.empty();//是否为空
ret.resize(10);//重新设置大小为10[长了默认0或者指定的值][短了就截断]
1
2
3

插入和删除(注意特有remove)

ret.push_back(1);//尾部插入数据1
ret.push_front(3);//头部插入数据3
ret.pop_back();//尾删
ret.front_back();//头删
ret.insert(++ret.begin(),10);//第二个位置插数据10
ret.erase(++ret.begin());//删除第二个位置数据
ret.remove(10);//删除链表中所有与10匹配的数据
ret.celar();//清空【另外一个不在书写】
1
2
3
4
5
6
7
8

数据存取

//链表不是连续空间不能用[]和at()跳跃访问
ret.front();//头结点数据
ret.back();//尾结点数据
1
2
3

反转(reverse)和排序

ret.reverse();//ret反转
//不支持随机访问的迭代器不能用sort(ret.begin(),ret.end())
ret.sort();//链表可以直接排序

1
2
3
4

二叉排序树set/multiset容器(只能用insert插入)

set不允许重复元素，multiset允许重复元素
set插入数据时自动排序

构造和赋值

set <int> ret;
set <int> ret_1(ret);//拷贝构造
set <int> ret_2;
ret_2 = ret;//等号赋值
//插入数据只有insert没有push
ret.insert(2);//插入数据2

1
2
3
4
5
6
7

大小和交换

ret.size();//大小
ret.empty();//是否为空
swap(ret,ret_1);//ret和ret_1交换

1
2
3
4

插入和删除

ret.insert(1);//插入数据1
ret.erase(ret.begin());//删除头元素
ret.erase(20);//删除数据20
ret.celar();//清空另外区间不再书写
1
2
3
4

查找和统计find\count【重点】

set <int>::iterator pos=ret.find(10);//返回的是迭代器
if(pos != ret.end())//pos不等于end就找到了
cout<<"找到了"<<endl;

ret.count(200);//统计数据200的次数
1
2
3
4
5

指定排序规则(set容器提前定义规则)

【另外注意set容器输出语法c++11前】

for(set<int,mycomper>::iterator it = ret1.begin();it!=ret1.end();it++)
	cout<<*it<<"   ";
1
2

c++11后输出语法

	for (auto it = ret1.begin(); it != ret1.end(); it++)
		cout << *it << "   ";
1
2

#include 
#include 
using namespace std;

class mycomper{
public:
bool operator()(int v1,int v2)const{///重载小括号
return v1>v2;
}
};

int main() {
	set <int,mycomper> ret1;
	ret1.insert(1);
	ret1.insert(2);
	ret1.insert(3);
for(set<int,mycomper>::iterator it = ret1.begin();it!=ret1.end();it++)
	cout<<*it<<"   ";
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

set容器自定义类型排序（类模板的运用）

注意重载小括号后面要加 const
自定义的类型排序必须要制定排序规则（年龄降序或者名字字典序）

#include 
#include 
#include 

using namespace std;


template <class STR, class INT>
class stu {
public:
	stu(STR name, INT age){
		this->name = name;
		this->age = age;
	}
	void show() {
		cout << "name:" << name << "    age:" << age << endl;
	}

	STR name;
	INT age;
};

class mycomper {
public:
	//加const不然C2784报错
	bool operator()(const stu<string, int>& p1, const stu<string, int>& p2) const {///重载小括号
		return p1.age > p2.age;
	}
};

int main() {
	//自定义数据类型要指定排序规则
	//不然C2784报错
	set <stu<string,int>,mycomper> s;
	stu<string, int> s1("赵艺", 20);		
	stu<string, int> s2("倩儿", 19);
	stu<string,int> s3("孙三", 22);
	s1.show();
	s2.show();
	s3.show();
	cout << endl;
	s.insert(s1);
	s.insert(s2);
	s.insert(s3);
	for (set<stu<string, int>>::iterator it = s.begin(); it != s.end(); it++)
		cout << "name:" << it->name << "    age:" << it->age<<endl;
		return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

对组pair【如要成对返回两个数据】

对组创建和访问

//不用包含头文件
pair<string ,int>p(values1,values2);//方法1
pair<string ,int>p =make_pair(values1,values2);//方法2
//对组的第一个数据是first第二个是second
cout<<p.first<<endl;
1
2
3
4
5

对组应用(并运用函数模板)

#include 
#include 
using namespace std;

template <typename STR ,typename INT>
pair<STR,INT> test(STR name,INT age){
	return pair<STR,INT>(name,age);
}

int main() {
	string name="李斯";
	int age = 20;
	string nam="里斯";
cout<<"姓名:"<<test(name,age).first<<endl;
cout<<"年龄:"<<test(name,age).second<<endl;
cout<<"年龄:"<<test(age,nam).second<<endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

二叉树map/multimap【使用率第三高】

特点

• 所有元素都是pair
• pair种第一个元素是key(键值)起索引作用(类似主键)、第二个值value(实值)
• 所有元素根据key自动排序
• map不允许重复key值元素[key不能重复value可重]
• multimap允许重复key值元素

构造和赋值

map<int,int> ret;//创建
ret.insert(pair<int,int>(1,10));//匿名对组(默认构造)
map<int,int> ret_1(ret);//拷贝构造
map<int,int>ret_2;
ret_2=ret;//赋值构造

1
2
3
4
5
6

如何输出

void show(map<int,int> &ret){
for(map<int,int>::iterator it=ret.begin();it!=ret.end();it++){
cout<<"key="<<(*it).first<<"   value:"<<it->second<<endl;
}
}
1
2
3
4
5

大小和交换(map|set没有容量只有大小)

ret.size();//大小
ret.empty();//是否为空
ret.swap(ret_1);//ret和ret_1互换
swap(ret,ret_1);//ret和ret_1互换
1
2
3
4

插入和删除

ret.insert(pair<int,int>(1,2));//匿名对组插入
ret.insert(make_pair(2,20));//make_pair插入
ret.isert(map<int,int>::value_type(3,30));//第三种
ret[4]=40;//第四总插入[不建议插入]
//但是可利用[]来访问
cout<<ret[4]<<endl;
//删除
ret.erase(ret.begin());//删除头
ret.erase(3);//删除key为3的数据,不按照value删除
//清空
ret.clear();
ret.erase(ret.begin(),ret.end());

1
2
3
4
5
6
7
8
9
10
11
12
13

查找find统计count

//find
ret.find(3);//查看key3是否存在，存在返回**迭代器**，不存在返回end();
map <int,int>::iterator pos = ret.find(3);
if(pos!=ret.end())cout<<"找到了"<<pos->second<<endl;
//count
ret.count(3);//按照key为3统计个数【map中为1/0】

1
2
3
4
5
6
7

排序sort

型排序设计规则

#include 
#include 
using namespace std;

class mycompare {
public :
	bool operator()(int p1,int p2)const {
		return p1 > p2;//注意这里这样写就可以
	}
};

void show(map<int, int,mycompare>& ret) {
	for (map<int, int,mycompare>::iterator it = ret.begin(); it != ret.end(); it++) {
		cout << "key=" << (*it).first << "   value:" << it->second << endl;
	}
}
int main() {
	map <int, int,mycompare> ret;
	ret.insert(pair<int, int>(4, 40));
	ret.insert(pair<int, int>(1, 10));
	ret.insert(pair<int, int>(2, 10));
	ret.insert(pair<int, int>(3, 30));
	ret.insert(make_pair(5, 30));

	show(ret);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

自定义数据类型排序(key排序)

#include 
#include 
using namespace std;

class stu {
public:
	stu(string name, int age) {
		this->name = name;
		this->age = age;
	}
public:
	string name;
	int age;
};
class mycompare {
public :
	bool operator()(const stu &p1,const stu &p2)const {
		return p1.age > p2.age;
	}
};

void show(map<stu,int,mycompare>& ret) {
	for (map<stu, int,mycompare>::iterator it = ret.begin(); it != ret.end(); it++) {
		cout << "age =" << (*it).first .age << "   name:" << it->first.name << "   value:" << it->second << endl;
	}
}
int main() {
	map <stu, int,mycompare> ret;
	stu s1("zhaoyi", 15);
	stu s2("qianer", 19);
	stu s3("sunsan", 13);
	stu s4("lisi", 22);
	stu s5("zhouwu", 17);
	ret.insert(pair<stu, int>(s1, 40));
	ret.insert(pair<stu, int>(s2, 10));
	ret.insert(pair<stu, int>(s3, 10));
	ret.insert(pair<stu, int>(s4, 30));
	ret.insert(make_pair(s5, 30));

	show(ret);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

总结

八大STL：【标粗为重点】

vector 数组
deque 双端数组
stack 栈
queue 队列
list 双向循环链表
set/multiset 二叉排序树
pair 对组
map/multimap 二叉树

遍历访问

可以遍历的(可随机访问)：(智能指针、下标[]、at)

vector
deque

不可随机访问

stack(每次只能看栈顶元素)
queue(可以查看队头和队尾元素，但只能队尾插入对头删除数据)
list(可以查看头结点和尾结点数据可在任意位置插入和删除，但是遍历和查找慢)

特殊情况map、set、pair

//输出规则set可换为map
for(set<int,int>::iterator it = ret.begin();it!=ret.end();it++)
cout<<_______________________-;//略
1
2
3

对组输出[对组有两个]

cout<<ret.first<<ret.second<<endl;
1

sort排序函数适合所有随机访问迭代器

支持sort排序：

vector、deque

//格式
sort(ret.begin(),ret.end());
1
2

list

ret.sort();
1

自定义规则

因为二者底层都是二叉树结构，所以插入(insert)时已经排序，需要更改规则用到下方函数

class mycompare{
public:
bool operator()(-------)const{
return a>b;//详细看上放代码
}
};
1
2
3
4
5
6