C++STL标准模板库容器详细实现算法代码

1.string类容器

#include<iostream>
#include<algorithm>
#include<functional>//仿函数greater<char>()可能需要的头文件
#include<string>//string 类
//注意#include<string.h>加了.H是字符串函数哦！
using namespace std;
//str0，str1，str2等都是对象而不是字符串！！！

//定义
void StrDefine()
{

	string str0;
	cout << str0 << "" << str0.empty() << endl;//调用empty()函数判断是否为空字符串，空字符串返回true 1

	string str1(5, 'a');//5表示字符a的个数
	cout << str1 << "" << str1.empty() << endl;//非空字符串返回0
	
	string str2("abcdef");//字符串全部字符初始化
	cout << str2 << endl;

	string str3("ghjadc", 3);//字符串前3个初始化
	cout << str3 << endl;

	string str4(str2, 2, 3);
	//可用str2给str4初始化，（字符串下标从0开始）2表示下标2开始，3表示（包含下标2）后面的3个字符
	cout << str4 << endl;

	string str5("qwer", 0, 2);//也可重新定义一个字符串初始化，0表示下标0开始，2表示下标0开始后面的2个字符
	cout << str5 << endl;

	string str6(str2);//string拷贝构造函数
	cout << str6 << endl;
	
}

//属性
void StrAttribute()
{
	string str0;
	cout << "str0字符串为空字符串" << str0 << endl;
	cout << "str0字符串容量为"<<str0.capacity() << endl;//结果：空字符串str0有15容量
	cout << "str0字符串长度为" << str0.length() << endl;//结果：空字符串str0长度为0

	string str1(16, 'a');
	cout << "str1字符串为" << str1 << endl;
	cout << "str1字符串容量为" << str1.capacity() << endl;//结果：str1有31容量
	/*规律（vs编译器）：空字符串默认容量15，字符串中字符数量超过15后，15加16容量变为31，
	以后每超过一次容量都加16
	即：15->31->47->63...
	而vc编译器初始为31个容量*/

	string str2(5,'h');
	cout << "str2字符串为" << str2 << endl;
	cout << "str2字符串初始容量为" << str2.capacity() << endl;
	str2.reserve(16);//增加容量作用，参数必须在后面的范围内，小于16的等于没有增加总结：调用它之后，15-31-47-63.......
	cout << "增加后str2字符串容量为"<< str2.capacity()<< endl;
	cout << "str2字符串长度为" << str2.length() << endl;

	string str3("ghjadc");
	cout << "str3字符串为" << str3 << endl;
	cout << "str3字符串长度为" << str3.length() << endl;
	cout << "str3字符个数为" << str3.size() << endl;//字符个数=字符串长度

	str3.resize(3);//截断字符串，取前3个
	cout << "截断后str3字符串变为" << str3 << endl;
	cout << "截断后str3字符个数为" <<str3.size() << endl;
	cout << "截断后str3字符串长度为" << str3.length() << endl;
	cout << "截断后str3字符串容量为" << str3.capacity() << endl;

}

//输出
void StrCout()
{
	string str6("qkjhgf");
	cout << "重载输出运算符输出对象str6为"<<str6 << endl;//重载输出运算符
	cout << "c_str()函数输出为 "<< str6.c_str() << endl;
	/*
	char *p 初始指针p指向首地址
	p=new[15]  p申请一个容量15的空间
	空间里装着"qkjhgf"
	c_str()功能是 return p;输出首地址即返回备份"qkjhgf"而非原来的对象本身
	*/
	cout <<"str6对象按[下标] 输出单个字符为"<< str6[0] << endl;//按下标输出单个字符，第一个字符q的下标为0
	//但下标不可越界如str[8]否则会导致崩溃

	cout << "at()函数按下标输出单个字符为" << str6.at(2) << endl;
	
	//越界中断异常处理
	try
	{
		str6.at(9);


	}
	catch (...)//不知道条件可以catch(...)
	{
		cout << "下标越界中断" << endl;
	}

}

//修改
void StrChange()
{
	string str7("mnbcvz");
	cout << "原来的str7字符串为 " << str7 << endl;

	str7[0] = 'a';
	str7.at(5) = 'x';//可通过下标[]或者at()函数修改，但修改不可越界否则崩溃
	cout << "修改后的str7字符串为 " << str7 << endl;
}

//比较
void StrCompare()
{
	string str8("abcd");
	string str9("abe");
	//1比较字符串
	//比较字符串原则：从第一个字符挨个比较大小，不一样比较就结束，不管字符串长度，后面的字符不看

	cout << "重载比较运算符结果为" << (str8 >= str9) << endl;
	//重载比较运算符只有两种结果，真1假0

	cout << "str8调用compare函数与str9比较结果为" << str8.compare(str9) << endl;
	cout << "str8调用compare函数与具体字符串比较结果为" << str8.compare("aac") << endl;
	cout << "str8调用compare函数中间一段与str9比较结果为" << str8.compare(1, 2, str9) << endl;
	//1是开始比较的下标，2是长度
	cout << "str8调用compare函数中间一段与str9中间一段比较结果为" << str8.compare(1, 2, str9, 1, 2) << endl;

	//compare三种结果：a < b == -1, a == b ==0, a > b == 1
}

//复制
void StrCopy()
{
	//2复制字符串
	string str10("hjgkazx");
	char ArrStr[6] = { 0 };//初始化大小为6的字符数组
	str10.copy(ArrStr, 4, 2);//4是复制的字符串长度，2是开始复制的下标
	cout <<"调用copy复制后的字符数组为"<< ArrStr << endl;
}

//查找
void StrFind()
{
	string str11("qabcergf");
	string str12("abc");
	cout << "从str11中寻找str12结果为 "<<str11.find(str12, 0) << endl;
	//0是“从str11中开始寻找str12”的下标，如果找到返回的结果是小串（str12）中第一个字符在大串str11中的下标。
	cout <<"从str12中寻找str11结果为 "<< (int)str12.find(str11, 0) << endl;
	//"从str12中寻找str11",找不到强转为整形int返回-1
	cout << "从str12中寻找字符b的结果为 " << str12.find('b', 1);

	//返回字串substr
	cout << "返回str11的字串结果为" << str11.substr(2, 5) << endl;
	//2为开始返回的下标，5为字串长度

}

//交换
void StrSwap()
{
	string str13("mnbvz");
	string str14("asdfg");
	cout << "交换前str13为" << str13 << endl;
	cout << "交换前str14为" << str14 << endl;
	str13.swap(str14);//只可以交换对象不可以交换具体字符串
	cout << "交换后str13为" << str13 << endl;
	cout << "交换后str14为" << str14 << endl;

	cout <<"str13+str14结果为（str13在前面）"<< (str13 + str14) << endl;
}

//迭代器（通用智能指针，适用于所有容器）
void FunIterator()
{
	string str15("asdfgh");
	string::iterator ite;//相当于char*
	//int a;
	//char *a = str15.c_str();

	ite = str15.begin();//返回一个迭代器，指向字符串的第一个元素

	/*for (int i = 0; i < str16.size();i++)
	{
		cout << *ite << " ";//
		*ite++;
	}
	cout << str16;*/
	for (int i = 0; i < str15.size();i++)
	{
		cout << ite[i] << " ";//
		
	}
	cout<<endl;
	ite[2] = 'c';//改变第三个字符（且在迭代器ite指向头时，使用下标运算）
	cout << str15 << endl;
	/*
	for (ite; ite != str16.end(); ite++)//end()返回字符串最后一个元素的下一个位置
	{
		*ite='g';
		cout << *ite << " ";
			 

	}*/

	/*附加：重新申请空间15+16后，迭代器失效情况如下
	str15.append(18,'a'); //append作用是在str15后面加字符
	（解决方法）中间加入 ite=str15.begin();ite重新指向空间首地址
	再运行就不会报错
	*/

	//测试迭代器相关函数

	string str16("abcweq");
	string str17("jkl");
	cout<<"str16为" << str16 << endl;
	cout<<"str17为" << str17 << endl;


	//append作用是在str后面加字符
	cout << "str16调用append后为" << str16.append(str17.begin(), str17.end()) << endl;
	/*
	其他形式
	str16.append(str17.begin(), str17.begin()+3 );
	str17.end()等价于str17.begin()+3 //str17字符串长度为3
	begin()是第一个字符，end()是最后一个字符的后一个位置
	*/

	//erase删除str中的字符
	str16.erase(str16.begin());
	cout << "str16调用erase删除单个字符后为" << str16 << endl;

	str16.erase(str16.begin() + 1, str16.begin() + 4);
	//注意只删除开始位置(begin()+1)到结束位置前一个字符（begin()+3），结尾begin()+4不删除
	cout<< "str16调用erase删除一段字符串后为"<<str16 << endl;

	//insert插入
	str16.insert(str16.begin() + 2, 3,'H');
	//插入单个字符也可以： str16.insert(str16.begin() + 2, 'Q');
	cout <<"str16在第三个字符位置插入字符串后为"<< str16 << endl;

	str16.insert(str16.begin() + 3, str17.begin()+1,str17.end());
	cout << "str16在第4个字符位置插入str17中的一段字符串后为" << str16 << endl;
}


void BLHS(char c)//默认char c 根据元素决定也可以 int c 但不可以是迭代器类型
{
	cout << c;//不局限于输出每个字符，还可以计算等操作
}
/*For_each：遍历字符串+函数调用
注意使用for_each等函数前必须先加上头文件#include<algorithm>
*/
void StrFor_each()
{
	string str18("zxcvbnqwer", 6);
	cout << "str18遍历输出为";
	for_each(str18.begin(), str18.end(), BLHS);
	cout << endl;

	sort(str18.begin(), str18.end());
	cout << "str18默认从小到大排序后遍历输出为";
	for_each(str18.begin(), str18.end(), BLHS);
	cout << endl;

	//使用仿函数greater<char>前，部分编译器还要加入头文件#include<funtional>
	sort(str18.begin(), str18.end(), greater<char>());
	cout << "str18指定从大到小排序遍历输出为";
	for_each(str18.begin(), str18.end(), BLHS);
	cout << endl;
}


//菜单
void ShowMenu()
{
	cout << "***1.string定义***" << endl;
	
	cout << "***2.string属性***" << endl;
	
	cout << "***3.输出string***" << endl;
	
	cout << "***4.修改string***" << endl;
	
	cout << "***5.比较string***" << endl;
	
	cout << "***6.复制string***" << endl;

	cout << "***7.查找string***" << endl;

	cout << "***8.交换string***" << endl;
	
	cout << "***9.string迭代器***" << endl;

	cout << "***10.string遍历算法***" << endl;

	cout << endl;
}

//主函数
int main()
{
	
	int choice;
	char Wcontinue;
	ShowMenu();//等待用户选择菜单项

	while (true)
	{
		cout << "请输入您的选择:" ;
		cin >> choice;
		switch (choice)//case后按空格再按123...
		{
		case 1:StrDefine(); break;
		case 2:StrAttribute(); break;
		case 3:StrCout(); break;
		case 4:StrChange(); break;
		case 5:StrCompare(); break;
		case 6:StrCopy(); break;
		case 7:StrFind(); break;
		case 8:StrSwap(); break;
		case 9:FunIterator(); break;
		case 10:StrFor_each(); break;
		default:cout << "非法输入!!!" << endl;
		}
		cout << "如果你想继续输入请按y，否则按其他任意键结束！" << endl;
		getchar();
		Wcontinue = getchar();//所输入的值赋给Wcontinue
		if (Wcontinue == 'y')
			continue;
		else
			break;
		
	}

	system("pause");
	return 0;
}

2.vector容器(动态数组)

#include<iostream>
#include<vector>//动态数组向量
#include<algorithm>//for_each函数头文件
#include<ctime>//time.h
using namespace std;

//定义
void VectorDefine()
{
	vector<int>vec;//定义整形vector,<int>为参数列表
	struct STU
	{
		int age;

	};

	vector<struct STU>sss; //定义结构体vector
	vector<int*>qwe;//定义指针vector
	vector<string>str;//定义字符对象vector
	vector<char>ccc;//定义char字符数组等价于string

}

//构造函数
void VectorConstructor()
{
	vector<int>vec;//初始化没有元素
	//cout <<vec[0];输出崩溃

	vector<int>vec1(5);//声明5个有效元素，每个初始化为0
	cout << "vec1输出结果为" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << vec1[i]<<endl;

	}

	vector<int>vec2(3,12);
	cout << "int型vec2输出结果为" << endl;
	for (int i = 0; i < 3; i++)
	{
		cout << vec2[i] << endl;

	}

	vector<char>vec3(3,'a');
	cout << "char型vec3输出结果为" << endl;
	for (int i = 0; i < 3; i++)
	{
		cout << vec3[i] << endl;

	}

	//拷贝构造，注意向量对象的参数列表类型必须相通，如果用char给int初始化则会报错
	vector<int>vec4(vec2);//同int型初始化
	cout << "vec2给vec4初始化输出结果为" << endl;
	for (int i = 0; i < 2; i++)
	{
		cout << vec4[i] << endl;

	}

	vector<int>vec6(6, 3);
	//vector迭代器
	vector<int>::iterator ite1=vec6.begin();
	//相比较于string迭代器多了个参数列表<int>,以后迭代器一般都有参数列表
	vector<int>::iterator ite2 = vec6.end();

	vector<int>vec5(ite1, ite2);
	cout << "使用迭代器输出vec5结果为" << endl;
	for (int i = 0; i < 4; i++)
	{
		cout << vec5[i] << endl;

	}

}

//vector容量
void VectorCapacity()
{
	vector<int>vec6;
	cout<<"空vec6容量为" << vec6.capacity()<<endl;


	vector<int>vec7(5);
	cout << "vec7容量为" << vec7.capacity() << endl;

	vec7.push_back(1);//第六个位置添加元素1
	cout << "增加1次后vec7容量为" << vec7.capacity() << endl;
	//增加后容量为5+5/2取整=7

	vec7.push_back(1);//5+5/2=7
	vec7.push_back(1);//7+7/2=10
	cout << "增加2次后vec7容量为" << vec7.capacity() << endl;
	//vs每次容量增加一半，vc每次增加一倍


	//reserve（）修改容量,并且修改后的容量要比之前多，否则修改无效
	vector<int>vec8(8);
	cout << "原vec8容量为" << vec8.capacity() << endl;
	vec8.reserve(6);//修改vec8容量到6<8,无效仍为8
	cout << "修改后vec8容量为" << vec8.capacity() << endl;
	vec8.reserve(13);//修改vec8容量到13>8，有效为13
	cout<<"修改后vec8容量为"<<vec8.capacity()<<endl;

	//注意vector容量改变后，迭代器也会失效

}

//vector元素个数及容量
void VectorSize()
{
	vector<int>vec9(9); //元素个数为9,容量为9
	vec9.reserve(11);//修改容量为11
	cout << "修改容量为11后vec9的容量为为" << vec9.capacity() << endl;
	cout<<"修改容量为11后vec9的元素个数为"<<vec9.size() << endl;
	//元素个数仍为9，与容量无关

	vector<int>vec10(10);//元素个数为10,容量为10
	cout << "vec10初始元素个数为" << vec10.size() << endl;
	cout << "vec10初始容量为" << vec10.capacity() << endl;

	vec10.resize(7);//重新设置元素个数为7
	cout << "重新设置元素个数为7后vec10的容量为为" << vec10.capacity() << endl;
	cout << "重新设置元素个数为7后vec10的元素个数为" << vec10.size() << endl;
	//容量仍为10不变

	vec10.resize(13);//重新设置元素个数为13
	cout << "重新设置元素个数为13后vec10的容量为为" << vec10.capacity() << endl;
	cout << "重新设置元素个数为13后vec10的元素个数为" << vec10.size() << endl;
	//容量变为15

	/*总结：调用resize函数如果设置的元素个数 小于 原来的个数及容量，则原来的容量不变
	如果 大于原来的元素个数则容量增大为 原来的容量加上原容量的1/2取下整（舍去小数部分）
	*/


	//判断vector是否为空
	vector<int>vec11;
	vector<int>vec12(3,6);
	cout<<"vec11执行empty()函数结果:"<<vec11.empty()<<endl;//vec11为空返回1
	cout<<"vec12执行empty()函数结果:"<<vec12.empty()<<endl;//vec12不为空返回0

}
//fun函数每次将i*2再输出
void fun(int i)
{
	cout << i<< endl;

}
//输出
void VectorCout()
{
	//1输出单个
	vector<int>vec13;
	for (int i = 0; i <5; i++)
	{
		vec13.push_back(i);//添加五次元素
	}
	cout << "使用下标输出vec13中第2个元素为：" << vec13[1]<<endl;
	cout <<"使用at(i)函数输出vec13中第3个元素为："<< vec13.at(2) << endl; 
	cout << "调用back()函数输出vec13尾元素为：" << vec13.back() << endl;
	//注意vec13首元素不可以用vec13.begin()直接输出，需要借用迭代器

	//2输出全部
	cout << "使用下标输出vec13结果为:"<<endl;
	for (int i = 0; i < 5; i++)
	{
		cout << vec13[i] << endl;//下标输出

	}
	cout << "调用at(i)函数输出vec13结果为:" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << vec13.at(i) << endl; //at(i)函数输出

	}
	//at(i)与[i]效果一样



	//3迭代器输出情况
	vector<int>::iterator ddq1=vec13.begin();
	vector<int>::iterator ddq2=vec13.end();
	//vector<int>vec14(ddq1, ddq2);
	cout << "使用迭代器输出vec14结果为"<< endl;
	for (ddq1; ddq1!=ddq2; ddq1++)
	{
		cout << *ddq1<<endl;

	}
	
	//4for_each输出

	cout << "调用for_each输出vec13结果为："<<endl;
	for_each(vec13.begin()+1, vec13.end(), fun);

}

//6插入
void VectorAdd()
{
	vector<int>vec14;
	for (int i = 0; i < 6; i++)
	{
		vec14.push_back(i);//每次在尾部添加

	}

	vec14.insert(vec14.begin()+1, 66);//指定位置插入单个
	vec14.insert(vec14.begin() + 3,3,33);//指定位置插入多个

	vector<int>vec15(5, 8);//定义vec15
	vec14.insert(vec14.end(),vec15.begin()+1, vec15.begin() + 4);
	//在vec14指定位置中插入vec15的指定长度，注意尾部下标对应元素不插入，即只插入到vec15.begin() + 3
	
	for_each(vec14.begin(), vec14.end(), fun);

}

//7删除
void VectorDelete()
{
	vector<int>vec16;
	for (int i = 0; i < 7; i++)
	{

		vec16.push_back(i);

	}
	vec16.pop_back();//删除1个尾部元素
	cout << "删除1个尾部元素" << endl;
	for_each(vec16.begin(), vec16.end(), fun);//输出

	vec16.erase(vec16.begin() + 1);//删除指定位置的一个元素
	cout << "删除指定位置的一个元素" << endl;
	for_each(vec16.begin(), vec16.end(), fun);//输出

	vec16.erase(vec16.begin() + 3, vec16.end());//删除指定一段元素
	cout << "删除指定一段元素" << endl;
	for_each(vec16.begin(), vec16.end(), fun);//输出

	vec16.clear();
	cout << "删除全部元素" << endl;
	for_each(vec16.begin(), vec16.end(), fun);//输出

}

//8交换及排序
void VectorSwap_sort()
{
	vector<int>vec17;
	vec17.push_back(2);
	vec17.push_back(5);
	vec17.push_back(1);
	vec17.push_back(3);
	vec17.push_back(6);
	vector<int>vec18;
	vec18.push_back(4);
	vec18.push_back(0);
	vec18.push_back(1);
	vec18.push_back(2);
	vec18.push_back(9);
	cout << "交换前vec17:" << endl;
	for_each(vec17.begin(), vec17.end(), fun);//输出


	cout << "交换前vec18:" << endl;
	for_each(vec18.begin(), vec18.end(), fun);//输出

	vec17.swap(vec18);
	cout << "交换后vec17" << endl;
	for_each(vec17.begin(), vec17.end(), fun);//输出
	cout << "交换后vec18" << endl;
	for_each(vec18.begin(), vec18.end(), fun);//输出

	sort(vec17.begin(), vec17.end());
	cout << "vec17全部从小到大排序后" << endl;
	for_each(vec17.begin(), vec17.end(), fun);//输出

	sort(vec18.begin(), vec18.begin() + 3);//其实只排序 vec18.begin()到 vec18.begin() + 2位置
	cout << "vec18部分从小到大排序后" << endl;
	for_each(vec18.begin(), vec18.end(), fun);//输出

	sort(vec17.begin(), vec17.end(), greater<int>());//vec17全部从大到小排序
	cout << " vec17全部从大到小排序为" << endl;
	for_each(vec17.begin(), vec17.end(),fun);

	//乱序算法
	srand((unsigned int)time(0));//随机数生成，每次乱序输出结果都不一样，缺少这个只生成一种乱序输出结果
	random_shuffle(vec17.begin(), vec17.end());
	cout << " vec17乱序输出为" << endl;
	for_each(vec17.begin(), vec17.end(), fun);

}
// 菜单
void ShowMenu()
{
	cout << "***1.vector定义***" << endl;

	cout << "***2.vector构造函数***" << endl;

	cout << "***3.vector容量***" << endl;

	cout << "***4.vector元素个数***" << endl;

	cout << "***5.vector输出***" << endl;

	cout << "***6.vector插入***" << endl;

	cout << "***7.vector删除***" << endl;

	cout << "***8.vector交换及排序***" << endl;
}



//主函数
int main()
{

	int choice;
	char Wcontinue;
	ShowMenu();//等待用户选择菜单项

	while (true)
	{
		cout << "请输入您的选择:";
		cin >> choice;
		switch (choice)//case后按空格再按123...
		{
		case 1:VectorDefine(); break;
		case 2:VectorConstructor(); break;
		case 3:VectorCapacity(); break;
		case 4:VectorSize(); break;
		case 5:VectorCout(); break;
		case 6:VectorAdd(); break;
		case 7:VectorDelete(); break;
		case 8:VectorSwap_sort(); break;
		default:cout << "非法输入!!!" << endl;
		}
		cout << "如果你想继续输入请按y，否则按其他任意键结束！" << endl;
		getchar();//键盘输入
		Wcontinue = getchar();//所输入的值赋给Wcontinue
		if (Wcontinue != 'y')
			break;

	}

	system("pause");
	return 0;

}

3.List容器

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

struct Node
{
	int a;
	char c;

};//在函数外定义
void fun1(Node&d)
{
	cout << d.a << " " << (int)d.c<<endl;//char c 强转为int c

}
void fun2(Node&d)
{

	cout << d.a << " " << d.c << endl;

}

//定义构造函数
void ListDefine()
{
	cout << "输出lt结果" << endl;
	list<Node>lt;//无参数
	for_each(lt.begin(), lt.end(), fun1);

	cout << "输出lt1结果" << endl;
	list<Node>lt1(5);//指定元素个数，int值默认为0
	for_each(lt1.begin(), lt1.end(), fun1);

	cout << "输出lt2结果" << endl;
	Node no2 = { 11,'x' };//结构体定义，做对象lt2的参数传递
	list<Node>lt2(3,no2);//定义结构体类型的对象lt2
	for_each(lt2.begin(), lt2.end(), fun2);

	cout << "拷贝lt2输出lt3结果" << endl;
	list<Node>lt3(lt2);//另一个对象初始化当前对象
	for_each(lt3.begin(), lt3.end(), fun2);

	cout << "拷贝lt3输出lt4结果" << endl;
	list<Node>lt4(lt3.begin(),lt3.end());//另一个对象的部分初始化当前对象
	for_each(lt4.begin(), lt4.end(), fun2);

	cout << "利用迭代器输出lt5结果为" << endl;

	list<Node>::iterator ite1;
	ite1 = lt4.begin();
	ite1++;//自增支持
	//ite1 + 2;其他加减运算不支持
	list<Node>::iterator ite2 = lt4.end();
	ite2--;//自减支持
	list<Node>lt5(ite1, ite2);
	for_each(lt5.begin(), lt5.end(),fun2);
}

void ListSize()
{
	//LIST容器没有容量的概念，需要的时候直接添加节点即可
	
	Node no = { 6 ,'p'};
	list<Node>lt6(3,no);
	cout<<"lt6大小为" << lt6.size() << endl;
	for_each(lt6.begin(), lt6.end(), fun2);
	cout<< "调用empty结果:" << lt6.empty() << endl;

	lt6.resize(5);//lt大小设为5
	cout << "lt6大小为" << lt6.size() << endl;
	for_each(lt6.begin(), lt6.end(), fun2);
	//resize结果size变得比原来大时，多余的输出为0

	lt6.resize(0);//lt6大小设为0
	cout << "lt6大小为" << lt6.size() << endl;
	cout << "调用empty结果:" << lt6.empty() << endl;

}
//输出和添加
void ListCout()
{
	Node no = { 9,'m' };
	list<Node>lt7(4, no);
	for (list<Node>::iterator ite1 = lt7.begin(); ite1 != lt7.end(); ite1++)
	{
		cout << ite1->a << " " << ite1->c << endl;//指针指向->

	}
	//也可以用for_each输出，但链表不支持下标运算
	cout << endl;

	cout <<"返回尾元素"<< lt7.back().a << " " << lt7.back().c << endl;
	cout <<"返回头元素"<< lt7.front().a << " " << lt7.front().c << endl;
}

struct ST
{
	char x;
	int z;
	
	ST(char e,int d )
	{
		x = e;
		z = d;
	}
	bool operator==(const ST&k)//重载==用于结构体类型的比较
	{
		if (k.x == this->x && k.z == this->z)
		{
			return true;
		}
			return false;

	}

	bool operator< (const ST&p)//重载<用于结构体类型的排序；重载 > 会报错！
	{
	if (p.x > this->x )
	/*比较条件可以自定义，
		两个都比较：p.x > this->x && p.z > this->z
		比较一个：p.z > this->z
		条件是 > 从小到大排序
		条件是 < 从大到小排序
	*/
	
	return true;

	return false;

	}


};
void fun3(ST&y)
{
	cout << y.x << " " << y.z << endl;


}
//增加元素
void ListAdd()
{

	ST st1( 'q',15 );
	list<ST>lt9(6,st1);
	list<ST>lt8;//定义空对象lt8
	cout << "头尾分别添加后" << endl;
	lt8.push_front(ST ('a',199 ));//头添加
	lt8.push_back(st1);//尾添加
	for_each(lt8.begin(), lt8.end(), fun3);

	cout << "insert指定位置插入单元素后" << endl;
	list<ST>::iterator ite3 = lt8.begin();
	lt8.insert(ite3, ST('g', 77));
	for_each(lt8.begin(), lt8.end(), fun3);

	cout << "insert插入多元素后" << endl;
	//前面插入过一次，此时ite3已经指向第二个位置
	ite3--;//ite3重新指向第一个位置
	lt8.insert(ite3,3, ST('j', 98));
	for_each(lt8.begin(), lt8.end(), fun3);

	cout << "insert插入另一个向量的中间一段后" << endl;
	list<ST>::iterator ite9 = lt9.begin();//迭代器ite9指向对象lt9首位置
	ite9++;//有效：迭代器ite9自增指向第二个
	lt8.insert(ite3,ite9, lt9.end());
	//无效：lt8.insert(ite3++,ite9++, lt9.end());中，对迭代器自增自减虽然不报错，但貌似无任何作用，
	for_each(lt8.begin(), lt8.end(), fun3);
}
void ListDelete()
{
	list<ST>lt10;
	lt10.push_back(ST('a', 12));
	lt10.push_back(ST('b',13));
	lt10.push_front(ST('C', 15));
	lt10.push_back(ST('D', 11));
	lt10.push_back(ST('E', 32));
	lt10.push_front(ST('H', 17));
	lt10.push_front(ST('Q', 85));
	cout << "删除前lt10为" << endl;
	for_each(lt10.begin(), lt10.end(), fun3);

	lt10.pop_front();//删除首元素
	lt10.pop_back();//删除尾元素
	cout << "删除首尾元素后lt10为" << endl;
	for_each(lt10.begin(), lt10.end(), fun3);

	cout << "删除一段元素后lt10为" << endl;
	list<ST>::iterator ite1 = lt10.begin();
	
	lt10.erase(ite1, --lt10.end());//删除首位置直到尾-1位置的一段全部元素
	//由于lt10.end()是尾+1位置，前置--使其指向尾位置，后置--先删除元素再--无意义。
	for_each(lt10.begin(), lt10.end(), fun3);

	lt10.clear();//清除全部元素

	lt10.push_back(ST('a', 12));
	lt10.push_back(ST('b', 13));
	lt10.push_back(ST('C', 15));
	lt10.push_back(ST('C', 15));
	lt10.push_back(ST('D', 11));
	lt10.push_back(ST('C', 15));
	lt10.push_back(ST('a', 17));
	lt10.push_back(ST('a',55 ));
	cout << "重新添加元素后再删除" << endl;
	lt10.erase(--lt10.end());//erase也可删除单个元素
	for_each(lt10.begin(), lt10.end(), fun3);

	cout << "删除指定元素后" << endl;
	lt10.remove(ST('b', 13));//必须删除元素全都对应，否则如lt10.remove(ST('B', 13));删除失败
	for_each(lt10.begin(), lt10.end(), fun3);

	cout << "删除连续的重复元素其中一个后" << endl;
	lt10.unique();
	for_each(lt10.begin(), lt10.end(), fun3);
}

//赋值，整个替换
void ListAssign()
{
	Node n1 = { 76,'v' };
	list<Node>lt11(3,n1);
	list<Node>::iterator ite1 = lt11.begin();
	cout << "初始状态lt11为" << endl;
	for_each(ite1, lt11.end(),fun2);

	list<Node>lt12;
	lt12.assign(++ite1, lt11.end());
	cout << "用lt11中的一段赋值给lt12后，lt12为" << endl;
	for_each(lt12.begin(), lt12.end(),fun2);


	Node n2 = { 98,'k' };
	lt12.assign(5, n2);
	cout << "直接用定义的结点n2赋值给lt12为" << endl;
	for_each(lt12.begin(), lt12.end(), fun2);

	lt12 = lt11;
	cout << "重载“=”赋值运算符将lt11赋值给lt12为" << endl;
	for_each(lt12.begin(), lt12.end(), fun2);
}
void ListOther()
{
	list<ST>lt13;
	lt13.push_back(ST('a', 12));
	lt13.push_back(ST('b', 13));
	lt13.push_back(ST('g', 15));
	lt13.push_back(ST('d', 15));
	lt13.push_back(ST('e', 11));
	cout << "初始lt13为" << endl;
	for_each(lt13.begin(), lt13.end(), fun3);
	
	list<ST>lt14(5, ST('H', 88));
	cout << "初始lt14为" << endl;
	for_each(lt14.begin(), lt14.end(),fun3);

	//1交换swap，1换2或者2换1都可以
	lt13.swap(lt14);//交换两个对象
	cout << "交换后lt13为" << endl;
	for_each(lt13.begin(), lt13.end(), fun3);
	cout << "交换后lt14为" << endl;
	for_each(lt14.begin(), lt14.end(), fun3);

	//2逆置reverse
	lt14.reverse();//逆置lt14元素
	cout << "逆置后lt14为" << endl;
	for_each(lt14.begin(), lt14.end(), fun3);

	//3sort()排序List容器内部成员函数

	lt14.sort();//无参情况
	cout << "重载运算符“<”并且只按字符从小到大排序后lt14为" << endl;
	for_each(lt14.begin(), lt14.end(), fun3);
	//如想从大到小排序可以改变重载<的条件或者调用reverse()逆置即可

	//4merge()合并
	//注意合并条件：必须是两个有序的list对象，都是升序或者降序，并且运算符重载符号条件也要一致
	list<ST>lt15;
	lt15.push_back(ST('m', 146));
	lt15.push_back(ST('n', 45));
	lt15.push_back(ST('o',35));
	lt15.merge(lt14);
	cout << "lt15和lt14合并后输出" << endl;
	for_each(lt15.begin(), lt15.end(), fun3);

	//5splice拼接函数：注意同一个对象只使用一次拼接函数（三种形式之一），否则报错！！！
	list<ST>lt16;
	lt16.push_back(ST('w', 16));
	lt16.push_back(ST('c', 4));
	lt16.push_back(ST('g', 5));
	cout << "lt16元素输出为" << endl;
	for_each(lt16.begin(), lt16.end(), fun3);
	/*
	两个参数情况
	lt16.splice(lt16.begin(), lt15);//
	cout << "lt16从头拼接lt15全部后为" << endl;
	for_each(lt16.begin(), lt16.end(), fun3);
	*/
	/*三个参数情况
	list<ST>::iterator ite15 = lt15.begin();
	lt16.splice(lt16.begin(), lt15, ite15);
	cout << "lt16从头拼接lt15一个元素后为" << endl;
	for_each(lt16.begin(), lt16.end(), fun3);
	*/

	//四个参数情况
	list<ST>::iterator ite15 = lt15.begin();
	lt16.splice(lt16.end(),lt15,++ite15,--lt15.end());
	cout << "lt16从尾部拼接lt15一段后为" << endl;
	for_each(lt16.begin(), lt16.end(), fun3);
	
	//6查找 利用迭代器输出查找结果
	 list<ST>::iterator ite11=find(lt16.begin(), lt16.end(), ST('w', 16));
	 cout << "查找结果为" << ite11->x << ite11->z << endl;
	 //查找成功就输出所查找元素，失败则程序崩溃
} 
// 菜单
void ShowMenu()
{
	cout << "***1.List定义***" << endl;

	cout << "***2.List大小***" << endl;

	cout << "***3.List输出***" << endl;

	cout << "***4.List增加***" << endl;

	cout << "***5.List删除***" << endl;

	cout << "***6.List赋值***" << endl;

	cout << "***7.List其他操作***" << endl;

	cout << "***8.***" << endl;

	cout << "***9.***" << endl;
}



//主函数
int main()
{

	int choice;
	char Wcontinue;
	ShowMenu();//等待用户选择菜单项

	while (true)
	{
		cout << "请输入您的选择:";
		cin >> choice;
		switch (choice)//case后按空格再按123...
		{
		case 1:ListDefine(); break;
		case 2:ListSize(); break;
		case 3:ListCout(); break;
		case 4:ListAdd(); break;
		case 5:ListDelete(); break;
		case 6:ListAssign(); break;
		case 7:ListOther(); break;
		default:cout << "非法输入!!!" << endl;
		}
		cout << "如果你想继续输入请按y，否则按其他任意键结束！" << endl;
		getchar();//键盘输入
		Wcontinue = getchar();//所输入的值赋给Wcontinue
		if (Wcontinue != 'y')
		break;

	}

	system("pause");
	return 0;
}

4.deque双端队列

#include<iostream>
#include<deque>
using namespace std;
/*
对比vector容器：
没有capacity()和reserve()
多了push_front和pop_front()其他一样
*/
int main()
{
	deque<int>dq1;
	
	dq1.push_front(3);
	dq1.push_front(1);
	dq1.push_front(2);
	dq1.pop_front();
	deque<int>::iterator ite1 = dq1.begin();
	for (ite1; ite1 != dq1.end(); ite1++)
	{
		cout << *ite1 << endl;

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

5.map有序容器

#include<iostream>
#include<map>
#include<algorithm>//for_each输出函数
#include<functional>//greater仿函数头文件
using namespace std;

//输出fun1函数
void fun1(pair<int, char>pr)
{
	cout << pr.first << " " << pr.second << endl;
	//first代表键值，second代表实值

}

//构造函数，无参，含参等
void MapConstructor()
{
	map<int, char>mp1;//键值int实值char
	
	typedef pair<int, char> in_pair;//名字嫌长可重命名为in_pair
	mp1.insert(in_pair(2, 'a'));//自动按键值排序，即使2，‘a’先插入输出也会排在后面!
	mp1.insert(pair<int, char>(1, 'b'));//插入一个键值对

	pair<map<int, char>::iterator, bool>pi;
	pi = mp1.insert(in_pair(3, 'q'));
	cout <<"先插入3，'q'结果为" <<pi.second << endl;
	pi = mp1.insert(in_pair(3, 'w'));
	cout << "再插入3，'w'结果为" << pi.second<<endl;
	//键值不可相同，相同键值后插入的那个无效，bool类型判断返回false0
	//实值可以相同

	mp1.insert(pair<int, char>(5, 'e'));
	mp1.insert(pair<int, char>(7, 'r'));

	map<int, char>::iterator ite1 = mp1.begin();
	ite1++;
	ite1++;
	ite1++;
	ite1++;
	//迭代器自增4次只能一次一次++，不可以直接ite1+4
	mp1.insert(ite1, pair<int, char>(4, 'd'));
	//此时4，‘d’添加位置虽然用迭代器指定添加在末尾，但是输出结果仍然按键值 4 排序在中间位置

	cout << "mp1为" << endl;
	for_each(mp1.begin(), mp1.end(), fun1);


	map<int, char>mp2;
	mp2.insert(pair<int, char>(6, 'p'));
	mp2.insert(++mp1.begin(), mp1.end());
	//注意之前添加的 6，‘p’ 仍然按键值排序输出
	cout << "mp2为" << endl;
	for_each(mp2.begin(), mp2.end(), fun1);


	map<int, char>mp3(mp1);//用mp1给mp3初始化
	cout << "map3为" << endl;
	for_each(mp3.begin(), mp3.end(), fun1);

	map<int, char>mp4(++mp1.begin(), --mp1.end());//也可用mp1一段给mp4初始化
	cout << "mp4为" << endl;
	for_each(mp4.begin(), mp4.end(), fun1);

	map<int, char>mp13;
	mp13.insert(pair<int, char>(78, 'p'));
	mp13 = mp1;//mp1直接给mp13赋值，会覆盖掉mp13之前添加的元素
	cout << "mp1直接给mp13赋值为" << endl;
	for_each(mp13.begin(), mp13.end(), fun1);

}

//属性
void MapAttribute()
{
	map<int, char>mp5;
	mp5.insert(pair<int, char>(2, 'a'));
	mp5.insert(pair<int, char>(4, 's'));
	mp5.insert(pair<int, char>(6, 'e'));
	mp5.insert(pair<int, char>(5, 'd'));
	cout << "mp5大小为" << mp5.size() << endl;
	cout << "mp5某个元素是否存在:" <<mp5.count(1)<< endl;
	cout << "mp5某个元素是否存在:" << mp5.count(4) << endl;
	cout << "mp5是否为空:" << mp5.empty() << endl;

	map<int, char>::iterator ite1 = mp5.begin();
	//定义迭代器利用循环将键值实值挨个输出
	cout << "mp5修改实值后循环输出为：" << endl;
	ite1->second = 'z';// 借助迭代器对mp5的实值修改，

	
	//mp5的键值无法修改！修改会破坏红黑树的结构
	//错误示范：ite1->first = 1;错误提示：表达式必须是可修改的左值，即键值为常量
	for (ite1; ite1 != mp5.end(); ite1++)
	{
		cout << ite1->first << " " << ite1->second << endl;

	}


}

//删除
void MapDelete()
{
	//增       mp5.insert(pair<int,char>(键值,'实值')); 其他形式等等。。。
	//改(实值)  迭代器ite1->second='实值';
	

	
	map<int, char>mp6;//定义
	//插入元素
	mp6.insert(pair<int, char>(0, 'f'));
	mp6.insert(pair<int, char>(2, 'c'));
	mp6.insert(pair<int, char>(4, 'v'));
	mp6.insert(pair<int, char>(43, 'r'));
	mp6.insert(pair<int, char>(5, 'i'));
	mp6.insert(pair<int, char>(7, 'p'));


	cout << "初始时mp6为" << endl;
	for_each(mp6.begin(), mp6.end(), fun1);

	//删除操作

	mp6.erase(mp6.begin());
	cout << "删除指定单个元素后mp6为" << endl;
	for_each(mp6.begin(), mp6.end(),fun1);

	mp6.erase(++mp6.begin(),--mp6.end());
	cout << "删除指定一段元素后mp6为" << endl;
	for_each(mp6.begin(), mp6.end(), fun1);

	mp6.erase(43);
	cout << "按键值删除单个元素后mp6为" << endl;
	for_each(mp6.begin(), mp6.end(), fun1);

	mp6.clear();
	cout << "清除全部元素mp6为" << endl;
	for_each(mp6.begin(), mp6.end(), fun1);

}

//查找
//注意Find查找结果返回迭代器
//count查找(键值)mp5.count(键值); 结果为 无：0或者有：1
void MapFind()
{
	map<int, char>mp7;//定义
		//插入元素
	mp7.insert(pair<int, char>(9, 'f'));
	mp7.insert(pair<int, char>(5, 'c'));
	mp7.insert(pair<int, char>(7, 'v'));
	mp7.insert(pair<int, char>(51, 'r'));
	mp7.insert(pair<int, char>(12, 'i'));
	mp7.insert(pair<int, char>(14, 'p'));

	//借助迭代器，根据键值来查找
	
	map<int, char>::iterator ite1;
	ite1= mp7.find(9);
	//查找成功返回所查找的迭代器
	cout << ite1->first << " " << ite1->second << endl;
	
	map<int, char>::iterator ite2;
	ite2 = mp7.find(88);
	//cout << ite2->first << " " << ite2->second << endl;
	//查找失败返回崩溃，其实是返回末尾元素的后一个end()
	//可借助以下的if条件语句判断是否返回end()
	if (mp7.find(88) == mp7.end())
		cout << "确实是" << endl;
	else
		cout << "不是呢" << endl;

}

//逆置排序及交换
void MapGreater_Swap()
{
	map<int, char,greater<int>>mp8;//参数列表加greater<int>定义,逆序输出mp8
	//插入元素
	mp8.insert(pair<int, char>(3, 'f'));
	mp8.insert(pair<int, char>(6, 'c'));
	mp8.insert(pair<int, char>(7, 'v'));
	mp8.insert(pair<int, char>(51, 'r'));
	mp8.insert(pair<int, char>(12, 'i'));
	mp8.insert(pair<int, char>(14, 'p'));

	//若使用迭代器，也在迭代器定义参数列表加上greater
	map<int, char, greater<int>>::iterator ite1=mp8.begin();
	cout << "逆置定义mp8输出为" << endl;
	for_each(ite1, mp8.end(), fun1);//迭代器输出
	
	map<int, char,greater<int>>mp9;
	mp9.insert(pair<int, char>(89, 'k'));
	mp9.insert(pair<int, char>(86, 'l'));
	mp9.insert(pair<int, char>(55, 'h'));
	cout << "交换前mp9为" << endl;
	for_each(mp9.begin(), mp9.end(), fun1);

	mp9.swap(mp8);
	cout << "交换后mp9为" << endl;
	for_each(mp9.begin(), mp9.end(), fun1);
	//交换的两个对象类型必须相同即参数列表必须一致
	//正序的交换正序的，逆序的交换逆序的，否则失败！
}

// Map其他函数
void MapOther()
{
	map<int, char>mp10;
	mp10.insert(pair<int, char>(1, 'g'));
	mp10.insert(pair<int, char>(3, 'h'));
	mp10.insert(pair<int, char>(5, 'j'));
	mp10.insert(pair<int, char>(9, 's'));
	mp10.insert(pair<int, char>(14, 'a'));
	cout << "mp10为" << endl;
	for_each(mp10.begin(), mp10.end(), fun1);

	cout << "lower_bound寻找存在的键值3的结果" << mp10.lower_bound(3)->first << endl;
	//返回键值为3的结点
	cout << "lower_bound寻找不存在的键值4的结果" << mp10.lower_bound(4)->first << mp10.lower_bound(4)->second;
	cout << endl;//返回比4大最近的键值为5的结点
	//lower_bound 寻找键值如果存在则返回存在的节点，不存在就返回比所寻找键值 大的且最近的那个节点

	cout << "upper_bound寻找存在的键值3的结果为" << mp10.upper_bound(3)->first << endl;
	cout << "upper_bound寻找不存在的键值4的结果为" << mp10.lower_bound(4)->first << endl;
	//都返回键值为5的结点
	//upper_bound寻找不论是否存在的键值，结果都返回比所寻键值大且靠最近的那个节点


	pair<map<int, char>::iterator, map<int, char>::iterator>ret;
	//定义一对迭代器，ret.first和ret.second

	ret = mp10.equal_range(2);
	cout << "键值有4，equal_range(2)结果为" <<endl;
	cout << ret.first->first << " " << ret.first->second << endl;
	cout << ret.second->first<<" " << ret.second->second << endl;

	ret = mp10.equal_range(9);
	cout << "键值没有9，equal_range(9)结果为" << endl;
	cout << ret.first->first << " " << ret.first->second << endl;
	cout << ret.second->first << " " << ret.second->second << endl;

	//ret.first返回第1个迭代器调用->first和->second，相当于调用lower_bound 
	//ret.second返回第2个迭代器调用->first和->second，相当于调用upper_bound

	//注意这三个函数调用时的（键值）参数，最大只能在倒数第二个键值处，预留最大的那个元素返回，否则运行崩溃！
}
void ShowMenu()
{
	cout << "***1.Map构造函数***" << endl;

	cout << "***2.Map属性***" << endl;

	cout << "***3.Map删除***" << endl;

	cout << "***4.Map查找***" << endl;

	cout << "***5.Map逆序定义输出及交换***" << endl;

	cout << "***6.Map其他操作***" << endl;

	cout << "***7.Map***" << endl;

	cout << "***8.***" << endl;

	cout << "***9.***" << endl;
}

int main()
{
	ShowMenu();
	int choice;
	char Wcontinue;
	while (true)
	{
		cout << "请输入您的选择:";
		cin >> choice;
		switch (choice)
		{
		case 1:MapConstructor(); break;
		case 2:MapAttribute(); break;
		case 3:MapDelete(); break;
		case 4:MapFind(); break;
		case 5:MapGreater_Swap(); break;
		case 6:MapOther(); break;
		default: cout << "What is your problem?!" << endl;
		}
		cout << "if you want to continue,please press y! " << endl;
		cout << "else press any others!" << endl;
		//getchar();
		cin.get();
		Wcontinue = cin.get ();
		if (Wcontinue != 'y')
			break;
	}
	system("pause");
	return 0;
}

6.set容器

#include<iostream>
#include<set>
#include<string>//添加string对象必备
using namespace std;

//构造函数
void SetConstructor()
{
	set<string>st1;//set没有键值实值之分，且元素不可重复，否则添加的重复元素无效
	st1.insert("acx");//无string可能提示未声明的标识符
	st1.insert(string("czd"));
	st1.insert("basd");
	st1.insert("bdzsa");
	set<string>::iterator ite1 = st1. begin();

	cout << "st1为" << endl;
	for (ite1; ite1 != st1.end();ite1++)
	{
		cout << *ite1 << endl;
	}
	cout << endl;
}

//属性
void SetDefine()
{
	//无容量capacity
	set<string>st2;//set没有键值实值之分，且元素不可重复，否则添加的重复元素无效
	st2.insert("adw");
	st2.insert(string("qwe"));
	st2.insert("qwed");
	st2.insert("zsa");

	cout <<"st2是否为空："<< st2.empty() << endl;
	cout << "st2尺寸为:";
	cout << st2.size() << endl;

	//由于键值不重复，count只有两种结果：有为1，无为0
	cout << "count（we）结果:";
	cout<<st2.count("we")<<endl;
	cout << "count（adw）结果:";
	cout << st2.count("adw")<<endl;

	
}

/*其他操作：

增；
改：键值不可改，实值可改。建议不改，会破坏结构，修改直接用map
查：输出
删除：erase三种还有clear
find()
swap
从大到小排序，从小到大排序
lower_bound(key)
upper_bound(key)
equal_range(key)
等都参照map

multiset和set区别即：multimap和map区别
键值重复，计数，find返回第一个键值...
*/
int main()
{
	SetConstructor();
	SetDefine();
	system("pause");
	return 0;
}