STL-常用容器 - 技术栈

一、string容器

（一）string本质：

string是c++风格的字符串，而string本质上是一个类

string 和 char * 的区别：

char * 是一个指针
string是一个类，类内部封装的char*，管理这个字符串，是一个char*容器。

特点：

string类内部封装了很多成员方法（例如：查找 find ，拷贝 copy ，删除 delete 替换 replace，插入 insert）
string管理char*所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责

（二）string构造函数

构造函数原型：

string（）； //创建一个空的字符串例如：string str；
string（const char* s） //使用字符串s初始化
string（const string& str）；//使用一个string对象初始化另一个string对象
string（int n，char c）； //使用n个字符c初始化

cpp 复制代码

#include <iostream>
using namespace std;
//string 构造函数
//string（）；   //创建一个空的字符串 例如：string str；
//string（const char* s） //使用字符串s初始化
//string（const string& str）；//使用一个string对象初始化另一个string对象
//string（int n，char c）； //使用n个字符c初始化
void test01() {
	
	string s1;//默认构造
	const char* str = "hello world";
	string s2(str);//使用字符串初始化
	cout <<"s2="<<s2<<endl;
	string s3(s2);//使用string对象初始化 拷贝构造
	cout << s3 << endl;
	string s4(10, 'a');//使用10个字符'a'初始化
	cout << s4 << endl;

}

int main() {
	test01();



	system("pause");
	return 0;
}

（三）string 赋值操作

功能描述：

给string字符串进行赋值

赋值函数原型：

string& operator = （const char* s）； //char* 类型字符串，赋值给当前字符串
string& operator = （const string &s）；//把字符串s赋值给当前的字符串
string& operator =（char c）；//把字符串赋值给当前字符串
string& assign =（const char *s）； //字符串s赋值给当前的字符串
string& assign（const char *s，int n ）；//把字符串s的前n个字符赋值给当前的字符串
string& assign（const string &s）；//把字符串s赋值给当前字符串
string& assign（int n，char c）； //把n个字符c赋值给当前字符串

cpp 复制代码

#include <iostream>
using namespace std;
/*
string 的赋值操作
string& operator = （const char* s）； //char* 类型字符串，赋值给当前字符串
string& operator = （const string &s）；//把字符串s赋值给当前的字符串
string& operator =（char c）；//把字符串赋值给当前字符串
string& assign =（const char *s）； //字符串s赋值给当前的字符串
string& assign（const char *s，int n ）；//把字符串s的前n个字符赋值给当前的字符串
string& assign（const string &s）；//把字符串s赋值给当前字符串
string& assign（int n，char c）； //把n个字符c赋值给当前字符串

*/


void test02() {
	string str1;
	str1 = "hello world"; //string& operator = （const char* s）
	cout << "str1 =" << str1 << endl;

	string str2;
	str2 = str1;//string& operator = （const string &s）；
	cout << "str2=" << str2 << endl;

	string str3;
	str3 = 'a'; //string& operator =（char c）；
	cout << "str3=" << str3 << endl;

	string str4;
	str4.assign("hello C++"); //string& assign =（const char *s）；
	cout << "str4=" << str4 << endl;

	string str5;
	str5.assign("hello C++", 5);
	cout << "str5=" << str5 << endl;//string& assign（const char *s，int n ）；

	string str6;
	str6.assign(str5);
	cout << "str6=" << str6 << endl; //string& assign（const string &s）；

	string str7;
	str7.assign(5, 'a'); //string& assign（int n，char c）；
	cout << "str7=" << str7 << endl;

}
int main() {
	test02();


	system("pause");
	return 0;
}

（四）string 字符串拼接

功能描述：

实现在字符串末尾拼接字符串

函数原型：

string& operator +=（const char* str）； //重载+=操作符
string& operator +=（const char c ）； //重载+=操作符
string& operator +=（const string& str）； //重载+=操作符
string& append（const char *s）；//把字符串s连接到当前字符串结尾
string& append（const char *s，int n）；//把字符串s的前n个字符链接到当前字符串结尾
string& append（const string &s）；//同operator += （const string& str）
string& append（const string &s，int pos ，int n）；//字符串s中从pos开始的n个字符链接到字符串结尾

cpp 复制代码

#include <iostream>
using namespace std;
//string字符串拼接
/*
字符串拼接
string& operator +=（const char* str）； //重载+=操作符
string& operator +=（const char   c ）； //重载+=操作符
string& operator +=（const string& str）； //重载+=操作符
string& append（const char *s）；//把字符串s连接到当前字符串结尾
string& append（const char *s，int n）；//把字符串s的前n个字符链接到当前字符串结尾
string& append（const string &s）；//同operator += （const string& str）
string& append（const string &s，int pos ，int n）；//字符串s中从pos开始的n个字符链接到
*/

void test03() {
	string str1 = "我";
	str1 += "爱玩游戏";
	cout<<"str1=" << str1 << endl; //string& operator +=（const char* str）；
	str1 += ':';
	cout << "str1=" << str1 << endl;//string& operator +=（const char   c ）；
	string	str2 = "LOL DNF CF";
	str1 += str2; //string& operator +=（const string& str）；
	cout << "str1=" << str1 << endl;
	
	string str3 = "I";
	str3.append(" love"); //string& append（const char *s）；
	cout << "str3=" << str3 << endl;
	str3.append("game abcde", 4);
	cout << "str3=" << str3 << endl; //string& append（const char *s，int n）；
	//str3.append(str2); //string& append（const string &s）；
	//cout << "str3=" << str3 << endl;
	str3.append(str2, 0, 3);
	cout << "str3=" << str3 << endl; //string& append（const string &s，int pos ，int n）；


}


int main() {
	test03();
	system("pause");
	return 0;
}

（五）string查找和替换

功能描述：

查找：查找指定字符串是否存在
替换：在指定位置替换字符串

函数原型：

int find （const string& str，int pos = 0）const；//查找str第一次出现位置，从pos开始查找
int find （const char *s，int pos=0）const；//查找s第一次出现位置，从pos开始查找
int find （const char *s，int pos ，int n）const；//从pos位置查找s的前n个字符串第一次位置
int find （const char c，int pos =0）const；//查找字符c第一次出现的位置
int rfind（const string& str，int pos =npos）const ；//查找str最后一次位置，从pos开始查找
int rfind（const char* s，int pos =npos）const ； //查找str最后一次位置，从pos开始查找
int rfind（const char* s，int pos，int n）const；//从pos查找s的前n个字符最后一次位置
int rfind （const char c ，int pos =0）const；//查找字符c最后一次出现的位置
string & replace（int pos，int n，const string& str）；//替换从pos开始n个字符为字符串str
string & replace（int pos，int n，const char *s）；//替换从pos开始的n个字符为字符串s

cpp 复制代码

#include <iostream>
using namespace std;
//字符串查找和替换

//1.查找
void testFind() {

	string str1 = "abcdefgde";
	int pos = 	str1.find("de");//没有返回 -1
	if (pos == -1) {
		cout << "未找到字符串" << endl;
	}
	else {


		cout << "pos=" << pos << endl;
	}

	//rfind 和 find rfind 从右往左查  从左往右查
	pos = str1.rfind("de");
	cout << "pos=" << pos << endl;
}



//2.替换
void testReplace() {

	string str1 = "abcdefg";
	str1.replace(1, 3, "1111");//从1号位置起 3个字符替换成1111
	cout << str1 << endl;

}
int main() {
	testFind();
	testReplace();

	system("pause");
	return 0;
}

总结：

find查找是从左往右，rfind从右往左
find找到字符串后返回查找的第一个字符的位置，找不到返回-1
replace在替换时，要指定从哪个位置起，多少个字符，替换成什么样的字符串

（六）字符串比较

功能描述：

字符串之间的比较

比较方式：

字符串比较是按字符的ASCII码进行对比

= 返回 0

> 返回 1

< 返回 -1

函数原型

int compare（const string &s）const； //与字符串s比较
int compare（const char *s）const；//与字符串s比较

cpp 复制代码

#include <iostream>
using namespace std;
//字符串比较

void testCompare() {

	string str1 = "xello";
	string str2 = "zello";

	if (str1.compare(str2) == 0) {

		cout << "str1 等于 str2" << endl;
	}
	else if (str1.compare(str2) > 0) {
		cout << "str1 大于 str2" << endl;
	
	}
	else {
		cout << "str1 小于 str2" << endl;
	}
}



int main() {
	testCompare();

	system("pause");
	return 0;
}

（七）string 字符存取

string中单个字符串存取方式有两种

char & operator [ ](int n);//通过[ ]方式取字符
char& at（int n）；//通过at方法获取字符

cpp 复制代码

#include <iostream>
using namespace std;
//string 字符存取

void testAt() {
	string str = "hello";
	//1.通过[下标]访问单个字符
	for (int i = 0; i < str.size(); i++) {
		cout << "str["<<i<<"] = " << str[i] << endl; // 输出 h


	}
	cout << "*************************" << endl;
	//2.通过at方法访问单个字符
	for (int i = 0; i < str.size(); i++) {
		cout << "str[" << i << "] = " << str.at(i) << endl; // 输出 h


	}
 //修改单个字符
	str[0] = 'x';
	cout << "str = " << str << endl; // 输出 xello
	str.at(1) = 'x';
	cout << "str = " << str << endl; // 输出 xxllo
}




int main() {

	testAt();
	system("pause");
	return 0;



}

（八）string插入和删除

功能描述：

对string字符串进行插入和删除字符操作

函数原型：

string& insert（int pos，const char *s）； //插入字符串
string& insert （int pos，const string& str）;//插入字符串
string& insert （int pos，int n，char c）；在指定位置插入n个字符c
string& erase （int pos，int n =npos） //删除从pos开始的n个字符

cpp 复制代码

#include <iostream>
using namespace std;
//字符串的插入和删除
void testInsert() {
	string str = "hello";

	//插入
	str.insert(1, "111");
	cout << str << endl;

	//删除
	str.erase(1,3);
	cout << str << endl;

}

int main() {
	testInsert();
	system("pause");
	return 0;
}

（九）string子串

功能描述：

从字符串中获取想要的子串

函数原型：

string substr（int pos =0，int n =npos）const ；//返回由pos开始的n个字符组成的字符串

cpp 复制代码

#include <iostream>
using namespace std;
//子串

void testSubString() {
	string str = "abcdef";

	string Substr = str.substr(1, 3);
	cout << Substr << endl; //bcd

}
//使用操作
void testSubString02() {
	string str = "zhangsan@sina.com";
	//从邮件的地址中获取用户名的信息
	int pos = str.find("@");
	string username = str.substr(0, pos);
	cout << "用户名：" << username << endl;
}


int main() {
	testSubString();
	testSubString02();
	system("pause");
	return 0;
}

二、vector 容器

（一）vector基本概念

功能：

vector 数据结构和数组非常相似，也称为单端数组

vector与普通数组的区别：

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

动态扩展：

并不是在源空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间

vector容器的迭代器是支持随机访问的迭代器

（二）vector构造函数

功能描述：

创建vector容器

函数原型：

vector<T> v; //采用模版类实现，默认构造函数
vector(v.begin(),v.end()); //将v[begin(),end()）区间中的元素拷贝给自身
vector(n,elem); //构造函数将n个elem拷贝给本身
vector(const vector &vec); //拷贝构造函数

cpp 复制代码

#include<iostream>
using namespace std;
#include <vector>
//vector容器构造
void printVector(vector <int> &v) {

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {

		cout << *it<< " ";
	}

	cout << endl;

}



void test01()
{
 vector <int> v1;  //默认构造，无参构造

 for (int i = 0; i < 10; i++) {

	 v1.push_back(i);

 }
	 printVector(v1);

	 //通过区间的方式进行构造
	 vector<int> v2(v1.begin(), v1.end());

	 printVector(v2);

	 //n个elem方式构造
	 vector<int> v3(10, 100);

	 printVector(v3);
	 //拷贝构造
	 vector<int> v4(v3);

	 printVector(v4);

 



}



int main() {
	test01();

	system("pause");
	return 0;

}

（三）vector赋值操作

功能描述：

给vector容器进行赋值

函数原型：

vector& operator =(const vector &vec); //重载等号操作符
assign(beg,end); //将[beg,end)区间的数据拷贝赋值给本身
assign(n,elem); //将n个elem拷贝赋值给本身

cpp 复制代码

#include <iostream>
using namespace std;
#include <vector>
void printVector(vector<int>& v) {

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {

		cout << *it << " ";

	}
	cout << endl;

}



//vector 赋值
void test02() {

	vector <int> v1;
	for (int i = 0; i < 10; i++) {

		v1.push_back(i);
	}
	printVector(v1);
	//赋值
	vector<int> v2 = v1;
	printVector(v2);
	//assign
	vector<int> v3;
	v3.assign(v1.begin(), v1.end());
	printVector(v3);
	//n个elem
	vector<int> v4;
	v4.assign(10, 100);
	printVector(v4);


}

int main() {
	test02();

	system("pause");
	return 0;
}

（四）vector的容量大小

功能描述：

对vector容器的容量大小的操作

函数原型：

empty();//判断容器是否为空
capacity();//容器的容量
size();//返回容器中元素的个数
resize(int num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置

//如果容器变短，则末尾超出容器长度的元素被删除

resize(int num,elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。

//如果容器变短，则末尾超出容器容器长度的元素被删除

cpp 复制代码

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


void printVector(vector<int>& v) {

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {

		cout << *it << " ";

	}
	cout << endl;
}
void test01(){

	vector<int> v1;
	for (int i = 0; i < 10; i++) {

		v1.push_back(i);
	}
	printVector(v1);
	if (v1.empty()) {

		cout << "v1 为空" << endl;
	}
	else {

		cout << "v1不为空" << endl;
		cout << "v1的容量" << v1.capacity() << endl;//13 动态扩展
		cout << "v1的大小" << v1.size() << endl;
	}
	//重新指定大小
	v1.resize(15); //后面自动用0填充
	printVector(v1);
	cout << "v1的容量" << v1.capacity() << endl;
	cout << "v1的大小" << v1.size() << endl;

	//可以指定填充内容
	v1.resize(20, 100);
	printVector(v1);
	cout << "v1的容量" << v1.capacity() << endl;
	cout << "v1的大小" << v1.size() << endl;

	//比原来短 超出的部分会删掉
	v1.resize(5);
	printVector(v1);
	cout << "v1的容量" << v1.capacity() << endl;
	cout << "v1的大小" << v1.size() << endl;

}

int main() {

	test01();


	system("pause");
	return 0;
}

（五）Vecctor插入和删除

功能描述

对vector容器进行插入，删除操作

函数原型：

push_back(ele); //尾部插入元素ele
pop_back(); //删除最后一个元素
insert(const_iterator pos,ele); //迭代器指向位置pos插入元素ele
insert(const_iterator pos ,int cout ,ele);//迭代器指向位置pos插入count个元素ele
erase(const_iterator pos); //删除迭代器指向的元素
erase(const_iterator start,const_iterator end)；//删除迭代器从start到end之间的元素
clear();//删除容器中所有元素

cpp 复制代码

#include<iostream>
using namespace std;
#include <vector>
//vector插入和删除
/*push_back(ele);        //尾部插入元素ele
pop_back();      //删除最后一个元素
insert(const_iterator pos, ele);  //迭代器指向位置pos插入元素ele
insert(const_iterator pos, int cout, ele);//迭代器指向位置pos插入count个元素ele 
erase(const_iterator pos); //删除迭代器指向的元素
erase(const_iterator start, const_iterator end)；//删除迭代器从start到end之间的元素
clear();//删除容器中所有元素*/
void printVector(vector<int>& v) {

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {

		cout << *it << " ";


	}
	cout << endl;
}



void test01() {
	vector<int> v;
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	v.push_back(50);
	printVector(v);

	//尾删
	v.pop_back();
	printVector(v);
	//迭代器插入
	v.insert(v.begin(), 100);
	printVector(v);
	//count个元素插入
	v.insert(v.begin(), 2, 200);
	printVector(v);

	//迭代器删除
	v.erase(v.begin());
	printVector(v);
	//迭代器区间删除
	//v.erase(v.begin(), v.end()); //清空
	v.clear();
	printVector(v);

}


int main() {

	test01();
	system("pause");
	return 0;

}

（六）vector数据存取

功能描述：

对vector中的数据的存取操作

函数原型：

at（int idx）； //返回索引idx所指的数据
operator[ ]；//返回索引idx所指的数据
front（）；//返回容器中第一个数据元素
back（）；//返回容器中最后一个数据元素

cpp 复制代码

#include<iostream>
using namespace std;
#include <vector>
//vector容器 数据存取
void test01() {

	vector<int> v;
	for (int i = 0; i < 10; i++) {

		v.push_back(i);
	}
	//利用[]方式访问数组元素
	for (int i = 0; i < v.size(); i++) {
		cout << v[i] << " ";

	}
	cout << endl;

	//利用 at()方式访问数组元素
	for (int i = 0; i < v.size(); i++) {
		cout << v.at(i) << " ";
	}
	cout << endl;

	//利用front()和back()访问数组首尾元素
	cout << "front():" << v.front() << endl;
	cout << "back():" << v.back() << endl;
}
	int main() {
	test01();


		system("pause");
		return 0;


}

（七）vector 互换容器

功能描述

实现两个容器内元素进行互换

函数原型：

swap（vec）; //将vec与本身的元素互换

cpp 复制代码

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

//vector 容器互换
void printVector(vector<int>& v) {

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {

		cout << *it << " ";

	}
	cout << endl;
}

//1.基本使用
void test01() {
	vector<int> v1;
	for (int i = 0; i < 10; i++) {

		v1.push_back(i);
	}
	printVector(v1);

	vector<int> v2;
	for (int i = 10; i > 0; i--) {

		v2.push_back(i);
	}
	printVector(v2);
	cout << "交换前：" << endl;

	cout << "交换后：" << endl;
	v1.swap(v2);
	printVector(v1);
	printVector(v2);
}

//2.实际用途
void test02() {
	vector<int> v;
	for (int i = 0; i < 100000; i++) {
		v.push_back(i);
	}
	cout << "v的容量" << v.capacity() << endl;
	cout << "v的大小" << v.size() << endl;
	v.resize(3);//重新指定大小
	cout << "v的容量" << v.capacity() << endl; //13w
	cout << "v的大小" << v.size() << endl;

	//巧用swap收缩内存
	vector<int>(v).swap(v);//匿名对象会自动回收
	cout << "v的容量" << v.capacity() << endl; //3
	cout << "v的大小" << v.size() << endl;
	


}
int main() {
	test01();
	test02();
	system("pause");
	return 0;
}

（八）vector预留空间

功能描述：

减少vector在动态扩展容量时的扩展次数

函数原型：

reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问

cpp 复制代码

#include <iostream>
using namespace std;
#include <vector>
//vector预留空间

void test01() {
	//vector预留空间
	
	vector<int> v;
	v.reserve(100000);
	int num = 0;//统计开辟次数  30次(不预留)
	int* p = NULL;
	for (int i = 0; i < 100000; i++) {

		v.push_back(i);
		if (p != &v[0]) {
			p=&v[0];
			num++;
		}
	}
	cout << "num=" << num << endl;
}

int main() {
	test01();

	system("pause");
	return 0;
}

三、deque 容器

（一）deque容器基本概念

功能：

双端数组，可以对头端进行插入删除操作

deque与vector区别：

vector对于头部的插入删除效率低，数据量大，效率低
deque相对而言，对头部的插入删除速度比vector快
vector访问元素时的速度会比deque快，这和两者内部实现有关

deque内部工作原理：

deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据

中控器维护的是每个缓冲区的地址，使得使用deque时向一片连续的内存空间

deque容器的迭代器也是支持随机访问的

（二）deque构造函数

功能描述：

deque容器构造

函数原型：

deque<T> deq T; //默认构造形式
deque（beg，end）；//构造函数将[beg,end）区间的元素拷贝给本身
deque（n，elem）；//构造函数将n个elem拷贝给本身
deque（const deque &deq）；//拷贝构造函数

cpp 复制代码

#include <iostream>
using namespace std;
#include <deque>
//deque 构造函数
void printDeque(const deque<int> &d){
    //如果加上const做修饰限定 那么迭代器也必须使用带有const的迭代器
    for(deque<int>::const_iterator it = d.begin();it !=d.end();it ++){
    	//*it=100;  使用const关键字限制了容器为只读状态，无法修改容器内的值
		
        cout<<*it <<" ";


    }
    cout << endl;

}
void test01()
{
    //1.默认构造
    deque<int> d1;
    for(int i=0;i<10;i++){

        d1.push_back(i);
    }

    printDeque(d1);
    //区间构造
    deque<int> d2(d1.begin(),d1.end());
    printDeque(d2);
    
    //n个element赋值
    deque<int> d3 (10,100);
    printDeque(d3);
    //4.拷贝构造
    deque<int> d4(d3);
    printDeque(d4);

    

}

int main(){
test01();


system("pause");
return 0;

}

（三）deque赋值操作

功能描述：

给deque容器进行赋值

函数原型：

deque& operator =(const deque & deq); //重载等号操作符
assign(beg,end); //将[beg,end)区间中的函数拷贝赋值给本身
assign(n,elem); //将n个elem拷贝给本身

cpp 复制代码

#include <iostream>
using namespace std;
#include <deque>
//deque容器赋值操作
void printDeque(const deque<int>& d) {

	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {

		cout << *it << " ";
	}
	cout << endl;

}
void test01() {
	deque<int>d1;
	for (int i = 0; i < 10; i++) {

		d1.push_back(i);
	}
	printDeque(d1);
	//1.等号赋值  operator = 赋值
	deque<int> d2 = d1;
	printDeque(d2);
	// 2.assign() 区间赋值
	deque<int> d3;
	d3.assign(d1.begin(), d1.end());
	printDeque(d3);
	//3.assign n个 elemt 赋值
	deque<int> d4;
	d4.assign(10, 100);
	printDeque(d4);




}
int main() {
	test01();



	system("pause");
	return 0;
}

（四）deque大小操作

功能描述：

对deque容器的大小进行操作

函数原型：

deque.empty( ); //判断容器是否为空
deque.size( ); //返回容器中的元素个数
deque.resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置

//如果容器变短，则末尾超出容器长度的元素被删除

deque.resize(num,elem); //重新指定容器的长度为num，若容器变长，则以elem填充新位置

//如果容器变短，则末尾超出容器长度的元素被删除

cpp 复制代码

#include <iostream>
using namespace std;
#include <deque>
//deque容器的大小操作
void printDeque(const deque<int> &d) {
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;

}
void test01() {
	deque<int> d1;
	for (int i = 0; i < 10; i++) {
		d1.push_back(i);
	}
	printDeque(d1);

	if (d1.empty()) {
		cout << "d1为空" << endl;
	}
	else {
		cout << "d1不为空" << endl;
		cout << "d1的大小为：" << endl;
		//deque容器没有容量的概念

	}
	//重新指定大小
	//d1.resize(15);
	d1.resize(15,1);
	printDeque(d1);
	d1.resize(5);
	printDeque(d1);
}

int main() {

	test01();
	system("pause");
	return 0;

}

（五）deque插入和删除

功能描述：

向deque容器中插入和删除数据

函数原型：

两端插入操作：

push_back(elem); //在容器尾部添加一个数据
push_front(elem); //在容器头部插入一个数据
pop_back( ); //删除容器最后一个数据
pop_front( ); //删除容器的第一个数据

指定位置操作：

insert(pos，elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置。
insert(pos,n,elem); //在pos位置插入n个elem数据，无返回值
insert(pos,beg,end); //在pos位置插入[beg,end)区间的数据，无返回值
clear( ); //清空容器的所有数据
erase(beg,end); //删除[beg,end ]的数据，返回下一个数据的位置
erase(pos); //删除pos位置的数据，返回下一个数据的位置

cpp 复制代码

#include <iostream>
using namespace std;
#include <deque>
//deque容器插入和删除
//两端操作
void printDeque(const deque<int>& d) {

	for (deque<int>::const_iterator it = d.begin(); it != d.end(); ++it) {
		cout << *it << " ";

	}
	cout << endl;

}


void test01() {
	deque<int> d1;
	//尾插
	d1.push_back(10);
	d1.push_back(20);
	//头插
	d1.push_front(30);
	d1.push_front(100);
	printDeque(d1); // 100 30 10 20

	//尾部删除
	d1.pop_back();
	printDeque(d1); // 100 30 10
	d1.pop_front();
	printDeque(d1); // 30 10

}
void test02() {
	deque<int> d2;
	d2.push_back(10);
	d2.push_back(20);
	d2.push_back(30);
	d2.push_back(40);
	d2.push_back(50);
	printDeque(d2); // 10 20 30 40 50

	//insert插入
	d2.insert(d2.begin(), 1000);
	printDeque(d2); // 1000 10 20 30 40 50
	d2.insert(d2.end(), 2000);
	printDeque(d2); // 1000 10 20 30 40 50 2000
	d2.insert(d2.begin(),2, 2000);
	printDeque(d2); // 2000 2000 1000 10 20 30 40 50 2000

	deque<int> d3;
	d3.push_back(1);
	d3.push_back(2);
	d3.push_back(3);

	d3.insert(d3.begin(), d2.begin(), d2.end());
	printDeque(d3); // 2000 2000 1000 10 20 30 40 50 2000 1 2 3
	deque<int>::iterator it = d3.begin();
	it++;
	d3.erase(it);
	printDeque(d3); //  2000 1000 10 20 30 40 50 2000 1 2 3
	//按照区间的方式删除
	d3.erase(d3.begin(), d3.end() - 3);
	printDeque(d3);   // 1 2 3
	d3.clear();
	printDeque(d3);   
	
}

int main() {
	test01();
	test02();
	system("pause");
	return 0;

}

总结：

插入和删除提供的位置是迭代器
尾插 --- push_back
尾删 --- pop_back
头插 --- push_front
头删 --- pop_front

（六）deque数据存取

功能描述：

对deque中的数据的存取操作

函数原型：

at(int idx); //返回索引idx所指的数据
operator[ ]; //返回索引idx所指的数据
front( ); //返回容器中第一个数据元素
back( ); //返回容器中最后一个数据元素

cpp 复制代码

#include <iostream>
using namespace std;
#include <deque>
//deque容器的存取操作
void test01() {
	deque<int> d;
	d.push_back(1);
	d.push_back(2);
	d.push_back(3);
	d.push_front(100);
	d.push_front(200);

	//通过 [ ] 访问元素
	for (int i = 0; i < d.size(); i++) {
		cout<<d[i]<<" ";

	}
	cout << endl;

	//通过 at() 访问元素
	for (int i = 0; i < d.size(); i++) {
		cout << d.at(i) << " ";
	}
	cout << endl;
	cout << "第一个元素为" << d.front() << endl;
	cout << "最后一个元素" << d.back()  << endl;

}

int main() {
	test01();

	system("pause");
	return 0;
}

（七）deque排序

功能描述：

利用算法实现对deque容器排序

算法

sort(iterator beg,iterator end) //对beg和end 区间内的元素进行排序

cpp 复制代码

#include <iostream>
using namespace std;
#include <deque>
#include<algorithm>
//deque容器的存取操作
void test01() {
	deque<int> d;
	d.push_back(1);
	d.push_back(2);
	d.push_back(3);
	d.push_front(100);
	d.push_front(200);
	//默认从小到大
	//对于支持随机访问的迭代器的容器，都可以利用sort排序

	sort(d.begin(),d.end()); //对容器进行排序
	//通过 [ ] 访问元素
	for (int i = 0; i < d.size(); i++) {
		cout<<d[i]<<" ";

	}
	cout << endl;
}

int main() {
	test01();

	system("pause");
	return 0;
}

四、stack容器

（一）stack 基本概念

概念：stack是一种先进后出的数据结构

栈不允许有遍历行为
栈可以判空
栈可以返回元素

（二）stack常用接口

功能描述：栈容器常用对外接口

构造函数：

stack<T> stk; //stack采用模版类实现，stack对象的默认构造形式
stack(const stack &stk); //拷贝构造函数

赋值操作：

stack& operator =(const stack &stk)；//重载等号操作符

数据存取：

push(elem); //向栈顶添加元素
pop(); //从栈顶移除第一个元素
top(); //返回栈顶元素

大小操作：

empty( ); //判断堆栈是否为空
size( ); //返回栈的大小

cpp 复制代码

#include <iostream>
using namespace std;
//栈STACK 容器
#include <stack>

void test01() {
	//特点：符合先进后出数据结构
	stack<int> s;
	//入栈
	s.push(1);
	s.push(2);
	s.push(3);
	s.push(4);

	//只要栈不为空，查看栈顶，并执行出栈操作
	while (!s.empty()) {
		cout << s.top() << " ";
		s.pop();
		cout<<"栈中的数据个数：" << s.size() << endl;
	}
	cout << endl;
}

int main() {
	test01();

	system("pause");
	return 0;
}

五、queue容器

（一）queue基本概念

（二）queue 常用接口

功能描述：

queue<T> que; //queue采用模板类实现，queue对象的默认构造形式
queue(const queue &que); //拷贝构造函数

赋值操作：

queue& operator=（const queue &que）；//重载等号操作符

数据存取：

push（elem）；//往队尾添加元素
pop （）；//从队头移除第一个元素
back（）；//返回最后一个元素
front （）；//返回第一个元素

大小操作

empty（）；//判断堆栈是否为空
size（）； //返回栈的大小

cpp 复制代码

#include <iostream>
using namespace std;
#include <queue>
#include <string>
//queue用法

class Person{
    public:
    Person(string name ,int age){
        this->m_name = name;
        this->m_age = age;

    }
    string m_name;
    int m_age;
};



void test01(){
    //创建队列
    queue<Person> q;
    //准备数据
    Person p1 ("唐三藏",180);
    Person p2 ("孙悟空",660);
    Person p3 ("猪八戒",500);
    Person p4 ("沙和尚",440);

    //入队
    q.push(p1);
    q.push(p2);
    q.push(p3);
    q.push(p4);

    //判断只要队列不为空，查看队头，查看队尾，出队
    while (!q.empty()){
        //查看队头
        cout<<"队头元素---姓名： " << q.front().m_name << "年龄 : " <<q.front().m_age << endl;
        //查看队尾
        cout<<"队尾元素---姓名： " << q.back().m_name << "年龄 : " <<q.back().m_age << endl;
        //出队
        q.pop();
    }

}



int main() {
    test01();


    system("pause");
    return 0;
}

六、List容器

（一）list基本概念

功能：将数据进行链式存储

链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的

链表的组成：链表由一系列节点组成

节点的组成：一个是存储数据元素的数据域，另一个是存储下一个节点地址的指针域

STL中的链表是一种双向循环链表

优点：

可以对任意位置进行快速的插入或删除元素
采用动态分配，不会造成内存的浪费和溢出
链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素

缺点：

对于容器的遍历速度，没有数组快占用的空间比数组大
链表灵活，但是空间（指针域）和时间（遍历）额外耗费大

由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器

List有一个重要的性质，插入操作和删除操作都不会造成原有迭代器的失效，这在Vector不成立

（二）List的构造函数

功能描述：

创建list容器

函数原型：

list<T> lst; //list采用模板类实现，对象的默认构造形式
list(beg,end); //构造函数将[beg,end)区间的元素拷贝给本身
list(n,elem); //构造函数将n个elem拷贝给本身
list(const list &lst); //拷贝构造函数

cpp 复制代码

#include <iostream>
using namespace std;
#include <list>
#include <string>
//list容器的打印函数
void printList(const list<int> &l){
    for(list<int>::const_iterator it =l.begin();it!=l.end();it++){
        cout<<*it<<" ";
    }
    cout<<endl;

}
void test01(){
    //创建list容器
    list<int> L1;
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);
    L1.push_back(50);
    printList(L1);
    //区间方式构造
    list<int> L2(L1.begin(),L2.end());
    printList(L2);
    //拷贝构造
    list<int> L3(L2);
    printList(L3);
    //n个100
    list<int> L4(10,1000);
    printList(L4);

}

int main() {
    test01();
    system("pause");
    return 0;
}

（三）list赋值与交换

功能描述：

给list容器进行赋值，以及交换list容器

函数原型：

assign（beg，end）；//将[beg,end)区间的数据拷贝给本身
assign（n，elem）； //将n个elem赋值给本身
list& operator =（const list &lst）；//重载等号操作符
swap（lst）；//将lst与本身的元素互换

cpp 复制代码

#include <iostream>
using namespace std;
#include <list>
#include <string>
//list 赋值与转换
//赋值
void printList(const list<int> &L)
{
    for(list<int>::const_iterator it = L.begin();it!=L.end(); it++)
        {
            cout<<*it<<" ";
        }
    cout<<endl;    
}
void test01()
{
    list<int> L1;
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);
    printList(L1);
    list<int> L2;
    L2=L1; // operator = 赋值
    printList(L2);
    list<int> L3;
    L3.assign(L2.begin(),L2.end());
    printList(L3);
    list<int> L4;
    L4.assign(10,100);
    printList(L4);
}
void test02()
{   
    list<int> L1;
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);
    list<int> L2;
    L2.assign(10,100);
    cout<<"交换前： "<<endl; 
    printList(L1);
    printList(L2);
    L1.swap(L2);
    cout<<"交换后： "<<endl;
    printList(L1);
    printList(L2);
}
int main(){
    //test01();
    test02();
    system("pause");
    return 0;
}

（四）list大小操作

功能描述：

对list容器的大小进行操作

函数原型：

size( ); //返回容器中元素的个数
empty( ) //判断容器是否为空
resize(num); //重新制定容器的长度为num，若容器边长，则以默认值填充新位置
//如果容器变短，则末尾超出容器长度的元素被删除
resize(num,elem)； //重新制定容器的长度为num，若容器变长，则以elem填充新位置
//如果容器变短，则末尾超出容器长度的元素被删除

cpp 复制代码

#include <iostream>
using namespace std;
#include <list>
//list容器的大小操作
void printList(const list<int> &L)
{
    for(list<int>::const_iterator it =L.begin();it !=L.end();it++)
    {
        cout<< *it <<" ";
    }
    cout<<endl;
}

void test01()
{
    list<int> L1;
    L1.push_back(20);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);
    printList(L1);
    //判断容器是否为空
    if (L1.empty())
    {
        cout << "L1为空" <<endl;
    }
    else
    {
        cout << "L1不为空" << endl;
        cout << "L1的元素个数为：" <<L1.size() << endl;
    }
    //重新指定大小
    L1.resize(10,10000);
    printList(L1);
    L1.resize (2);
    printList(L1);
}

int main()
{
    test01();
    system("pause");
    return 0;

}

（五）list插入和删除

功能描述：

对list容器进行数据的插入和删除

函数原型：

push_back(elem); //在容器尾部加入一个元素
pop_back(); //删除容器中最后一个元素
push_front(elem); //在容器开头插入一个元素
pop_front(); //在容器开头移除第一个元素
insert(pos,elem); //在pos位置插入elem元素的拷贝，返回新数据的位置
insert(pos,n,elem); //在pos位置中插入n个elem数据，无返回值
insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值
clear();//移除容器所有数据
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置
erase(pos);//删除pos位置的数据，返回下一个数据的位置
remove(elem);//删除容器中所有与elem值匹配的元素

cpp 复制代码

#include <iostream>
using namespace std;
#include <list>
//list容器的插入与删除
/*
push_back(elem);  //在容器尾部加入一个元素
pop_back();  //删除容器中最后一个元素
push_front(elem);  //在容器开头插入一个元素
pop_front();  //在容器开头移除第一个元素
insert(pos,elem);  //在pos位置插入elem元素的拷贝，返回新数据的位置
insert(pos,n,elem); //在pos位置中插入n个elem数据，无返回值
insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值
clear();//移除容器所有数据
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置
erase(pos);//删除pos位置的数据，返回下一个数据的位置
remove(elem);//删除容器中所有与elem值匹配的元素
*/
void printList(const list<int> &L)
{
    for(list<int>::const_iterator it =L.begin();it !=L.end();it++)
    {
        cout<< *it <<" ";
    }
    cout<<endl;
}

void test01()
{
    list<int> L1;
    //尾部插入
    L1.push_back(20);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);
    //头部插入
    L1.push_front(50);
    L1.push_front(60);
    printList(L1); //60 50 20 20 30 40
    //尾部删除
    L1.pop_back();//60 50 20 20 30
    //头部删除
    L1.pop_front();// 50 20 20 30
    //insert 插入
    L1.insert(L1.begin(),1000);
    printList(L1); //1000 50 20 20 30 
    //删除
    list<int>::iterator it =L1.begin();
    L1.erase(it);//50 20 20 30
    L1.erase(++it);// 50 20 30
    //移除
    L1.push_back(10000);// 50 20 30 10000
    L1.push_back(10000);// 50 20 30 10000 10000
    L1.remove(10000); // 50 20 30 
    //清空
    L1.clear();
   
}

int main()
{
    test01();
    system("pause");
    return 0;

}

（六）数据存取

功能描述：

对list容器中数据进行存取

函数原型：

front( ); //返回第一个元素
backl( ); //返回最后一个元素

cpp 复制代码

#include <iostream>
using namespace std;
#include <list>
//list容器  数据存取

void printList(const list<int> &L)
{
    for(list<int>::const_iterator it =L.begin();it !=L.end();it++)
    {
        cout<< *it <<" ";
    }
    cout<<endl;
}

void test01()
{
    list<int> L1;
    //尾部插入
    L1.push_back(20);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);
    //List本质是链表，不是用连续线性空间存储数据，迭代器也是不支持随机访问的  不能跳跃性的取数据 只能 ++/--
    cout<<"第一个元素为：" << L1.front() << endl;
    cout<<"最后一个元素为：" <<L1.back() << endl;
}
int main()
{
    test01();
    system("pause");
    return 0;
}

（七）list 反转和排序

功能描述：

将容器中的元素反转，以及将容器中的数据进行排序

函数原型：

reverse(); //反转链表
sort(); //链表排序

cpp 复制代码

#include <iostream>
using namespace std;
#include <list>
#include <algorithm>
//list容器的反转和排序
bool myCompare(int v1,int v2)
{
    //降序 就让第一个数大于第二个数
    return v1 > v2;
}
void printList(const list<int> &L)
{
    for(list<int>::const_iterator it =L.begin();it !=L.end();it++)
    {
        cout<< *it <<" ";
    }
    cout<<endl;
}

void test01()
{
    list<int> L1;
    L1.push_back(20);
    L1.push_back(10);
    L1.push_back(30);
    L1.push_back(40);
    L1.push_back(50);
    printList(L1); //20 10 30 40 50 
    //反转
    L1.reverse();
    printList(L1); //50 40 30 10 20
    //排序
    //所有不支持随机访问的迭代器的容器，不可以用标准算法排序
    //不支持随机访问迭代器的容器，内部会提供对应的一些算法
    cout<< "排序前：" <<endl;
    printList(L1);
    //sort(L1.begin(),L1.end());  错误
    L1.sort(); //默认升序
    L1.sort(myCompare)；//降序排列

}
int main()
{
    test01();
    system("pause");
    return 0;
}

七、set容器

（一）set容器基本概念

简介：

所有元素都会在插入时自动去排序

本质：

set/multiset属于关联式容器，底层结构是用二叉树实现的

set和multiset的区别：

set容器不允许有重复的元素
multiset允许有重复的元素

（二）set构造和赋值

功能描述：创建set容器以及赋值

构造：

set<T> st; //默认构造函数
set(const set &st); //拷贝构造函数

赋值：

set& operator = (const set &st); //重载等号操作符

#include<iostream>
using namespace std;
#include<set>
//set 容器构造和赋值
void printSet(set<int> &s)
{
for(set<int>::iterator it = s.begin();it !=s.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
}
void test01()
{
set<int> s1;
//插入数据只有insert的方式
s1.insert(65);
s1.insert(60);
s1.insert(40);
s1.insert(70);
//set容器的特点 1.所有容器插入时自动排序 2.set容器不允许插入重复值
printSet(s1);
//拷贝构造
set<int>s2(s1);
printSet(s2);
//等号赋值
set<int> s3;
s3=s2;
printSet(s3);
}

int main()
{
test01();
system("pause");
return 0;

}

总结：

set容器插入数据时用insert
色图容器哦插入的数据会自动排序

（三）set大小和交换

功能描述：

统计set容器大小以及交换set容器

函数原型：

size(); //返回容器中元素的数目
empty();//判断容器是否为空
swap();//交换两个集合容器

cpp 复制代码

#include<iostream>
using namespace std;
#include<set>
//set 容器大小和交换
void printSet(set<int> &s)
{
    for(set<int>::iterator it = s.begin();it !=s.end();it++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
}
//大小
void test01()
{
    set<int> s1;
    //插入数据只有insert的方式
    s1.insert(65);
    s1.insert(60);
    s1.insert(40);
    s1.insert(70);
    //判断容器是否为空
    if(s1.empty())
    {
        cout << "容器为空" << endl;
    }else
    {
        cout <<"容器不为空" << endl;
        cout <<"容器的大小为" << s1.size() << endl;
    }

    
}
//交换
void test02()
{
    set<int> s1;
    //插入数据只有insert的方式
    s1.insert(65);
    s1.insert(60);
    s1.insert(40);
    s1.insert(70);
    set<int> s2;
    //插入数据只有insert的方式
    s2.insert(10);
    s2.insert(30);
    s2.insert(20);
    s2.insert(40);
    cout << "交换前：" <<endl;
    printSet(s1);
    printSet(s2);

    cout << "交换前：" <<endl;
    s1.swap(s2);
    printSet(s1);
    printSet(s2);
    
}

int main()
{
    test01();
    test02();
    system("pause");
    return 0;

}

（四）set插入和删除

功能描述：

set容器进行插入数据和删除数据

函数原型：

insert(elem); //在容器中插入元素
clear(); //清楚所有元素
erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器
erase(beg,end); //删除区间[beg，end）的所有元素，返回下一个元素的迭代器
erase(elem); //删除容器中值为elem的元素

cpp 复制代码

#include<iostream>
using namespace std;
#include<set>
//set 容器的插入和删除
void printSet(set<int> &s)
{
    for(set<int>::iterator it = s.begin();it !=s.end();it++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
}
//大小
void test01()
{
    set<int> s1;
    //插入数据只有insert的方式
    s1.insert(65);
    s1.insert(60);
    s1.insert(40);
    s1.insert(70);
    printSet(s1);
    //删除
    s1.erase(s1.begin()); //删除了第一个元素
    printSet(s1);
    //删除重载版本
    s1.erase(60);
    printSet(s1);
    //清空
    //s1.erase(s1.begin(),s1.end());
    s1.clear();
    printSet(s1);


    
}


int main()
{
    test01();
    
    system("pause");
    return 0;

}

（五）set容器的查找和统计

功能描述：

对set容器进行查找数据以及统计数据

函数原型：

find(key); //查找key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回set.end()
count(key); //统计key的元素个数

cpp 复制代码

#include<iostream>
using namespace std;
#include<set>
//set 容器的查找和统计
void printSet(set<int> &s)
{
    for(set<int>::iterator it = s.begin();it !=s.end();it++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
}
//大小
void test01()
{
    set<int> s1;
    //插入数据只有insert的方式
    s1.insert(65);
    s1.insert(60);
    s1.insert(40);
    s1.insert(70);
    printSet(s1);
    //查找
    //因为查找时返回的是迭代器，所以要用迭代器接受结果
    set<int>::iterator pos =s1.find(400);
    if(pos!=s1.end())
    {
        cout<<"找到元素"<<*pos <<endl;
    }else{
        cout<<"未找到元素"<<endl;
    }
}
    //统计
    void test02(){
    set<int> s1;
    //插入数据只有insert的方式
    s1.insert(65);
    s1.insert(60);
    s1.insert(40);
    s1.insert(70);
    s1.insert(70);
    s1.insert(70);

    int num =s1.count(70);
    //对于set来说结果不是0就是1 因为set中不允许有重复元素
    cout<<"num="<<num<<endl;
    }

int main()
{
    test01();
    test02();
    
    system("pause");
    return 0;

}

（六）set和multiset区别

区别：

set不可以插入重复数据，而multiset可以
set插入数据的同时会返回插入结果，表示插入成功
multiset不会检测数据，因此可以插入重复数据

cpp 复制代码

#include<iostream>
using namespace std;
#include<set>
//set 容器和multiset的区别
void printSet(set<int> &s)
{
    for(set<int>::iterator it = s.begin();it !=s.end();it++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
}
void test01()
{
    set<int> s1;
    //插入数据只有insert的方式
    s1.insert(65); //插入时会检测
    s1.insert(60);
    s1.insert(40);
    //用队组接收结果
    pair<set<int>::iterator,bool> ret = s1.insert(70);
    if(ret.second){
        cout<<"第一次插入成功"<<endl;
    }else{
        cout<<"第一次插入失败"<<endl;
    }
    ret =s1.insert(70);
        if(ret.second){
        cout<<"第二次插入成功"<<endl;
    }else{
        cout<<"第二次插入失败"<<endl;
    }
    multiset<int> s2; //允许插入重复的值
    s2.insert(10);  //直接插不检测
    s2.insert(20);
    for(multiset<int>::iterator it = s2.begin();it!=s2.end();it++){
        cout<<*it<<" ";
    }
    cout<<endl;
   
}
int main()
{
    test01();
    system("pause");
    return 0;

}

（七）pair队组创建

功能描述：

成对出现的数据，利用对组可以返回两个数据

两种创建方式：

pair<type,type> p (value1,value2);
pair<type,type> p =make_pair(value1,value2);

cpp 复制代码

#include<iostream>
using namespace std;
#include<string>
//pair对组的创建
void test01(){
    //第一种方式
    pair<string,int> p ("Tom",19);
    cout<<"姓名：" <<p.first <<",年龄：" <<p.second <<endl;
    //第二种方式
    pair<string,int> p2 = make_pair("Jerry",20);
    cout<<"姓名：" <<p2.first <<",年龄：" <<p2.second <<endl;

}
int main(){
    test01();

    system("pause");
    return 0;
}

（八）set容器排序

主要技术点：

利用仿函数，可以改变排序规则

cpp 复制代码

#include <iostream>
using namespace std;
#include<string>
#include<set>
//仿函数
class MyCompare{
    public:
        bool operator()( const int a,const int b) const{
            return a>b;
        }
};
//set 容器排序
void test01(){
    set<int> s1;
    s1.insert(10);
    s1.insert(60);
    s1.insert(50);
    s1.insert(20);
    s1.insert(30);
    for(set<int>::iterator it = s1.begin();it!=s1.end();it++){
        cout<<*it<<" ";
    }
    cout<<endl;
    //指定排序规则  制定排序 从大到小
    
    set<int,MyCompare> s2;
    s2.insert(10);
    s2.insert(60);
    s2.insert(50);
    s2.insert(20);
    s2.insert(30);
    for(set<int，MyCompare>::iterator it = s2.begin();it!=s2.end();it++){
        cout<<*it<<" ";
    }
    cout<<endl;
}

int main(){

    test01();
    system("pause");
    return 0;
}

cpp 复制代码

#include <iostream>
using namespace std;
#include <set>
#include <string>
// set容器排序，存放自定义数据类型
class Person{
    public:
    Person(string name,int age){
        this->m_name = name;
        this->m_age = age;
    }
    string m_name;
    string m_age;
};
class ComparePerson{
    bool operator()(const Person& p1,const Person& p2) const
    {
        //按照年龄排序
        return p1.m_age > p2.m_age;
    }
};
void test01(){
    //自定义的数据类型，都会指定排序规则
    set<Person,ComparePerson> s;
    //创建Person对象
    Person p1("Tom",20);
    Person p2("Jerry",25);
    Person p3("Mike",30);
    s.insert(p1);
    s.insert(p2);
    s.insert(p3);

    for(set<Person,ComparePerson>::iterator it = s.begin();it!=s.end();it++){
        cout<<"姓名： "<<it->m_name <<" 年龄：" <<it->m_age<<endl;
    }

}

int main(){
    test01();
    system("pause");
    return 0;
}

八、map/multimap容器

（一）map基本概念

简介：

map中所有的元素都是pair
pair中第一个元素为key（键值），起到索引的作用，第二个元素为value（实值）
所有元素都会根据元素的键值自动排序

本质：

map/multimap属于关联式容器，底层结构使用二叉树实现的

有点：

可以根据key值快速找到value值

map和multimap的区别：

map不允许容器中有重复的key值元素
multimap允许容器有重复key值元素

（二）map构造和赋值

功能描述：

对map容器进行构造和赋值操作

函数原型：

构造：

map<T1,T2> mp; //map默认构造函数
map(const map &map); //拷贝构造函数

赋值：

map& operator =（const map &map）;重载等号操作符

cpp 复制代码

#include<iostream>
using namespace std;
#include<map>
void printMap(map<int,int> &m){
    for(map<int,int>::iterator it=m.begin();it!=m.end();it++){
        cout<<"Key:"<<it->first<<"value:"<<it->second<<endl;
    }
    cout<<endl;
}

void test01(){
    //创建map容器
    map<int,int> m;
    m.insert(pair<int,int>(1,10));
    m.insert(pair<int,int>(2,20));
    m.insert(pair<int,int>(3,30));
    m.insert(pair<int,int>(4,40));
    m.insert(pair<int,int>(5,50));
    printMap(m);
    //拷贝构造
    map<int,int> m2(m);
    printMap(m2);


}
int main(){
    test01();
    system("pause");
    return 0;
}

（三）map大小和交换

功能描述：

统计map容器大小以及交换map容器

函数原型：

size（）； //返回容器中元素的数目
empty（）；//判断容器是否为空
swap（st）； //交换两个集合容器

cpp 复制代码

#include<iostream>
using namespace std;
#include<map>
void printMap(map<int,int> &m){
    for(map<int,int>::iterator it=m.begin();it!=m.end();it++){
        cout<<"Key:"<<it->first<<"value:"<<it->second<<endl;
    }
    cout<<endl;
}

void test01(){
    //创建map容器
    map<int,int> m;
    m.insert(pair<int,int>(1,10));
    m.insert(pair<int,int>(2,20));
    m.insert(pair<int,int>(3,30));
    m.insert(pair<int,int>(4,40));
    m.insert(pair<int,int>(5,50));
    printMap(m);
    cout<<"m的大小为"<<m.size()<<endl;
    //拷贝构造
    map<int,int> m2;
    m2.insert(pair<int,int>(1,100));
    m2.insert(pair<int,int>(2,200));
    m2.insert(pair<int,int>(3,300));
    m2.insert(pair<int,int>(4,400));
    m2.insert(pair<int,int>(5,500));
    printMap(m2);
    cout<<"m2的大小为"<<m2.size()<<endl;
    m2.swap(m);
    printMap(m2);
    printMap(m);
    if(m2.empty()){
        cout<<"m2为空"<<endl;
    }else{
        cout<<"m2不为空"<<endl;
    }


}
int main(){
    test01();
    system("pause");
    return 0;
}

（四）map插入和删除

功能描述：

map容器进行插入数据和删除数据

函数原型：

insert（elem）； //在容器中插入元素
clear（）； //清楚所有元素
erase（pos）；//删除pos迭代器所指的元素，返回下一个元素的迭代器
erase(beg,end)；//删除区间[beg,end)的所有元素，返回下一个元素的迭代器
erase（key）；//删除容器中值为key的元素

cpp 复制代码

#include<iostream>
using namespace std;
#include<map>
//map容器插入和删除
void printMap(map<int,int> &m){
    for(map<int,int>::iterator it=m.begin();it!=m.end();it++){
        cout<<"Key:"<<it->first<<"value:"<<it->second<<endl;
    }
    cout<<endl;
}
void test01(){
    map<int,int> m;
    //插入第一种
    m.insert(pair<int,int>(1,10));
    //插入第二种
    m.insert(make_pair(2,20));
    //插入第三种
    m.insert(map<int,int>::value_type(3,30));
    //第四种
    m[4] = 40;  //不建议使用 容易出错  如果索引处没有 会自动创建一个 0的值
    cout<<m[5]<<endl; //如果索引处没有 会自动创建一个 0的值
    printMap(m);

    //删除
    m.erase(m.begin());
    printMap(m);
    m.erase(2);  //按照key删除
    printMap(m);

   // m.erase(m.begin(),m.end());
   m.clear();
    printMap(m);


}


int main(){
    test01();
    system("pause");
    return 0;

}

（五）map查找和统计

功能描述：

对map容器进行查找数据以及统计数据

函数原型：

find（key）； //查找key是否存在，若存在，返回改键的元素的迭代器；若不存在，返回set.end（）；
count（key）；//统计key的元素个数

cpp 复制代码

#include<iostream>
using namespace std;
#include<map>
//map容器查找和统计
void printMap(map<int,int> &m){
    for(map<int,int>::iterator it=m.begin();it!=m.end();it++){
        cout<<"Key:"<<it->first<<"value:"<<it->second<<endl;
    }
    cout<<endl;
}
void test01(){
    map<int,int> m;
    //插入第一种
    m.insert(pair<int,int>(1,10));
    //插入第二种
    m.insert(make_pair(2,20));
    //插入第三种
    m.insert(map<int,int>::value_type(3,30));
    //第四种
    m[4] = 40;  //不建议使用 容易出错  如果索引处没有 会自动创建一个 0的值
    cout<<m[5]<<endl; //如果索引处没有 会自动创建一个 0的值
    //查找
    map<int,int>::iterator pos = m.find(1);
    if(pos !=m.end()){
        cout<<"找到了元素key=" <<(*pos).first<<"value="<<(*pos).second<<endl;
    }else{
        cout<<"没找到元素"<<endl;
    }
    //统计
    int count = m.count(1);
    cout<<"count="<<count<<endl;

}

int main(){
    test01();
    system("pause");
    return 0;

}

（六）map容器排序

主要技术点：

利用仿函数，可以改变排序规则

cpp 复制代码

#include<iostream>
using namespace std;
#include<map>
class myCompare{

public:
    bool operator()(const int&a,const int& b) const{
        return a>b;
    }
};
//map容器排序
void printMap(map<int,int,myCompare> &m){
    for(map<int,int>::iterator it=m.begin();it!=m.end();it++){
        cout<<"Key:"<<it->first<<"value:"<<it->second<<endl;
    }
    cout<<endl;
}
void test01(){
    map<int,int,myCompare> m;
    m.insert(make_pair(1,10));
    m.insert(make_pair(2,20));
    m.insert(make_pair(3,30));
    m.insert(make_pair(4,40));
    m.insert(make_pair(5,50));
    for(map<int,int,myCompare>::iterator it=m.begin();it!=m.end();it++){
        cout<<"Key:"<<it->first<<"value:"<<it->second<<endl;
    }
    cout<<endl;


}


int main(){
    test01();
    system("pause");
    return 0;

}