标签：deque set cout insert 容器 list push include

一、deque容器。
1、功能。
deque容器底层实现其实就是一个双端数组，可以对头部进行插入与删除的操作。

2、deque容器迭代器？
支持随机访问迭代器。

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

void printDeque(deque <int> &d)
{
	for(deque<int>::iterator it = d.begin(); it!=d.end();it++)
	{
		cout << *it << " ";	
	}
	cout << endl;
} 

int main()
{
	deque <int>d1;
	d1.push_back(10);
	d1.push_back(20);
	d1.push_back(30);
	d1.push_back(40);
	printDeque(d1);

	deque <int>d2(d1.begin(),d1.end());
	printDeque(d2);

	deque <int>d3(10,100);
	printDeque(d3);

	deque <int>d4(d3);
	printDeque(d4);

	deque <int>d5;
	d5 = d4;
	printDeque(d5);

	deque <int>d6;
	d6.assign(d5.begin(),d5.end());
	printDeque(d6);

	deque <int>d7;
	d7.assign(10,9);
	printDeque(d7);

	if(d7.empty())
	{
		cout << "d7真的为空" << endl;
	}
	else{
		cout << "d7不为空" << endl;
		cout << "d7的大小:" << d7.size() << endl;
		//cout << "d7的容量:" << d7.capacity() << endl;
	}

	d7.push_back(100);
	d7.push_front(3);
	printDeque(d7);

	d7.pop_back();
	d7.pop_front();
	printDeque(d7);

	deque<int>::iterator it = d7.begin();
	d7.insert(it,1000);
	printDeque(d7);

	//d7.resize(15);
	//printDeque(d7);

	//d6.resize(15,6);
	//printDeque(d6);

	//d5.resize(5);
	//printDeque(d5);

	//d7.erase(d7.begin(),d7.end());
	//d7.clear();
	//printDeque(d7);

	cout << d7.at(1) << endl;
	cout << d7[1] << endl;

	cout << d7.front() << endl;
	cout << d7.back() << endl;

	cout << "---------------------------" << endl;
	deque <int>d8;
	d8.push_back(10);
	d8.push_back(20);
	d8.push_back(30);

	d8.push_front(100);
	d8.push_front(200);
	d8.push_front(300);

	cout << "=====排序前=====" << endl;
	printDeque(d8);

	//sort默认的排序方式是从小到大  升序
	//对于支持随机访问的迭代器容器，都可以利用sort算法来进行排序。
	//vector容器也是可以支持sort算法的。
	sort(d8.begin(),d8.end());
	
	cout << "=====排序后=====" << endl;
	printDeque(d8);

	return 0;
}

练习：考点：vector容器、deque容器、string容器、排序算法sort,、随机值rand()
案例描述：
有5名选手： 选手A，选手B，选手C，选手D，选手E。10个评委分别对每名选手打分，去除最高分，去除最低分，取平均分。

实现步骤。
1）创建五名选手，并存放在vector中。
2）遍历vector容器，取出来每一个选手，执行for循环，可以将10个评委的打分存放在一个deque的容器中。（提示:使用rand()随机分数即可，记得包含algorithm头文件）
3）利用sort算法对deque容器中分数排序，去除最高分和最低分。
4）deque容器遍历一遍，累加总分。
5）获取平均分。
6）将每一个选手的名字和平均分输出即可。 

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

class Person{
public:
	Person(string name,int score)
	{
		this->m_Name = name;
		this->m_Score = score;
	}

	string m_Name;
	int m_Score;
};

void createPerson(vector <Person> &v)
{
	string nameSeed = "ABCDE";

	int i;
	int score;
	string name;

	for(i=0;i<5;i++)
	{
		name = "Person";
		name += nameSeed[i];  //选手A

		score = 0;  //设置平均分为0

		//创建一个选手。
		Person p(name,score);

		v.push_back(p);
	}
}

void setScore(vector <Person> &v)
{
	int i;
	int score;
	int sum;
	int avg;
	for(vector<Person>::iterator it = v.begin() ; it!=v.end() ;it++)
	{
		deque <int>d;
		for(i=0;i<10;i++)
		{
			score = rand()%41+60;
			d.push_back(score);
		}

		
		sort(d.begin(),d.end());

		d.pop_back();
		d.pop_front();

		sum = 0;
		for(deque<int>::iterator dit = d.begin();dit!=d.end();dit++)
		{
			sum += *dit;
		}

		avg = sum / d.size();

		it->m_Score = avg;
	}
}

int main()
{
	srand(time(NULL));

	vector <Person>v;
	createPerson(v);

	setScore(v);

	for(vector<Person>::iterator it = v.begin() ; it!=v.end() ;it++)
	{
		cout << "name = " << it->m_Name << "  score = " << it->m_Score << endl;
	}

	return 0;
}

二、stack容器。
stack是一种先进后出的数据结构，它只有一个出口，叫栈顶。
栈只有顶端才会被外界使用，因此栈不允许有遍历行为。

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

int main()
{
	stack <int>s;
	s.push(10);
	s.push(20);
	s.push(30);

	cout << "s栈的大小:" << s.size() << endl;

	stack <int>s2(s);
	cout << "s2栈的大小:" << s.size() << endl;

	stack <int>s3;
	s3 = s2;
	cout << "s3栈的大小:" << s.size() << endl;

	//只要栈不为空，那么就查看栈顶元素，执行出栈操作。
	while( !s.empty())
	{
		//查看栈顶元素
		cout << "栈顶元素:" << s.top() << endl;

		//出栈
		s.pop();
	}

	return 0;
}

三、queue容器。
概念：queue容器是一种先进先出的结构，它有两个口。

队列容器允许从一端新增元素，从另一端移除元素。
队列中队头与队尾才可以被外界使用，因此队列不允许有遍历行为。
队列中进数据  -> 入队。
队列中出数据  -> 出队。

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

class Person{
public:
	Person(string name,int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	string m_Name;
	int m_Age;
};

int main()
{
	queue <Person>q;

	Person p1("唐僧",200);
	Person p2("孙悟空",100);
	Person p3("猪八戒",50);
	Person p4("沙僧",30);

	q.push(p1);
	q.push(p2);
	q.push(p3);
	q.push(p4);

	cout << "队列的大小:" << q.size() << endl;

	//只要队列不为空，那么就查看队尾与队头的元素。
	while( !q.empty() )
	{
		cout << "------------" << endl;
		cout << "队头元素 - 姓名:" << q.front().m_Name << " 年龄:" << q.front().m_Age << endl;
		cout << "队尾元素 - 姓名:" << q.back().m_Name << " 年龄:" << q.back().m_Age << endl;
		q.pop();
	}

	return 0;
}

四、list容器。
功能： 链式储存数据。
迭代器： 由于链表不是一段连续空间，所以链表的迭代器只能支持前移和后移，属于双向迭代器。1、基本函数。

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

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

int main()
{
	list <int>L1;

	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);

	printList(L1);

	list <int>L2(L1.begin(),L1.end());
	printList(L2);

	list <int>L3(10,100);
	printList(L3);

	list <int>L4(L3);
	printList(L4);

	list <int>L5;
	L5.assign(L4.begin(),L4.end());
	printList(L5);

	list <int>L6;
	L6 = L5;
	printList(L6);

	cout << "=====互换前=====" << endl;
	printList(L2);
	printList(L6);
	cout << "L6的大小:" << L6.size() << endl;

	L6.swap(L2);

	cout << "=====互换后=====" << endl;
	printList(L2);
	printList(L6);
	cout << "L6的大小:" << L6.size() << endl;

	if(L6.empty())
	{
		cout << "L6为空" << endl;
	}
	else{
		cout << "L6不为空" << endl;
	}

	L6.resize(10,7);
	printList(L6);

	L6.push_back(10);
	printList(L6);

	L6.pop_back();
	printList(L6);

	L6.push_front(20);
	printList(L6);

	L6.pop_front();
	printList(L6);

	list<int>::iterator it = L6.begin();
	it++;
	cout << *it << endl;  //20

	L6.insert(it,1000);
	printList(L6);

	cout << *it << endl;

	L6.erase(it);
	printList(L6);

	//L6.clear();
	//printList(L6);

	L6.remove(7);
	printList(L6);

	cout << L6.front() << endl;
	cout << L6.back() << endl;

	return 0;
}

2、反转与排序。

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

//反转与排序。
void printList(list <int> &L)
{
	for(list<int>::iterator it = L.begin();it!=L.end();it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

bool mycompare(int v1,int v2)
{
	//降序：让第一个数字大于第二个数字就可以了。
	return v1 > v2;
}

int main()
{
	list <int>L1;
	L1.push_back(20);
	L1.push_back(10);
	L1.push_back(30);
	L1.push_back(50);
	L1.push_back(40);

	cout << "反转前:" << endl;
	printList(L1);

	L1.reverse();

	cout << "反转后:" << endl;
	printList(L1);

	cout << "======排序前=====" << endl;
	printList(L1);

	//所有不支持随机访问迭代器的容器，不可以使用标准算法sort()
	//sort(L1.begin(),L1.end());
	
	//不支持随机访问迭代器的容器，内部都会提供一些对应的算法给它。
	//L1.sort();  //默认是升序的。
	
	L1.sort(mycompare);  //实现降序

	cout << "======排序后=====" << endl;
	printList(L1);

	return 0;
}

五、set容器的基本概念。
简介：所有元素都会在插入时自动被排序。
本质：set/multiset容器底层结构就是二叉树。

set/multiset区别？
set不允许容器中有重复的元素。
multiset允许容器中有重复的元素。

无论你是使用set，还是multiset，头文件都是#include <set>

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

void printSet(set <int>&s)
{
	for(set<int>::iterator it = s.begin();it!=s.end();it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

int main()
{
	set <int>s;

	//set容器没有push_back,只有insert。
	s.insert(10);
	s.insert(10);
	s.insert(40);
	s.insert(30);
	s.insert(50);
	s.insert(20);
	s.insert(90);
	s.insert(80);

	printSet(s);  //默认已经按升序排序了

	set <int>s2(s);
	printSet(s2);

	set <int>s3;
	s3 = s2;
	printSet(s3);

	if(s3.empty())
	{
		cout << "s3为空" << endl;
	}
	else{
		cout << "s3不为空" << endl;
		cout << "s3的大小:" << s3.size() << endl;
	}

	set <int>s4;
	s4.insert(100);
	s4.insert(300);
	s4.insert(400);
	s4.insert(200);

	cout << "交换前" << endl;
	printSet(s3);
	printSet(s4);

	s3.swap(s4);

	cout << "交换后" << endl;
	printSet(s3);
	printSet(s4);

	//s3.clear();
	//printSet(s3);
	
	s3.erase(s3.begin());
	printSet(s3);


	set<int>::iterator pos = s3.find(500);
	if(pos != s3.end())
	{
		cout << "找到该元素:" << *pos << endl;
	}
	else{
		cout << "未找到该元素" << endl;
	}

	cout << s3.count(500) << endl;

	return 0;
}

六、pair对组的创建。
功能描述：
成对出现的数据，利用对组可以返回两个数据。

对组怎么创建？
方法有两种：
pair<type,type> p(value1,value2);
pair<type,type> p = make_pair(value1,value2);

#include <iostream>
using namespace std;

//对组的创建
/*
pair<type,type> p(value1,value2);
pair<type,type> p = make_pair(value1,value2);
*/

int main()
{	
	//第一种方式：
	pair<string,int> p("Tom",18);
	cout << "姓名:" << p.first << "年龄:" << p.second << endl;

	//第二种方式：
	pair<string,int> p2 = make_pair("ggy",18);
	cout << "姓名:" << p2.first << " 年龄:" << p2.second << endl;

	return 0;
}

七、set容器的排序。  --  set容器存放内置数据类型。

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

//set容器存放内置数据类型
//set容器的降序
class Mycompare{
public:
	//重载()
	bool operator()(int v1,int v2)
	{
		return v1 > v2;
	}
};

int main()
{
	set <int>s1;  //默认是升序。

	//插入之前

	s1.insert(10);
	s1.insert(40);
	s1.insert(20);
	s1.insert(50);
	s1.insert(30);

	//插入之后  
	for(set <int>::iterator it = s1.begin();it!=s1.end();it++)   
	{
		cout << *it << " ";
	}
	cout << endl;

	cout << "---------------------" << endl;
	set <int,Mycompare>s2;  //默认是降序。

	//插入之前
	s2.insert(10);
	s2.insert(40);
	s2.insert(20);
	s2.insert(50);
	s2.insert(30);

	//插入之后  
	for(set <int,Mycompare>::iterator it = s2.begin();it!=s2.end();it++)
	{
		cout << *it << " ";
	}
	cout << endl;




	//sort();   因为二叉树set容器是双向迭代器，所以不可以使用标准算法sort。
	//s.sort(); 内部也没有提供sort算法。
	
	//思考：能不能在插入之后，再进行降序？
	//答案：不可以的。
	
	//怎么才能降序？
	//答案：必须在插入之前，就要告诉它，要降序排序。

	return 0;
}

总结：
set容器，默认是升序的。
如果想降序，自己再写一个类，然后在类中重载()，让第一个数字大于第二个数字。
把类名写入到定义二叉树set对象<>里面即可，例如： set<int>s  ->  set<int,Mycompare>s;

标签：deque,set,cout,insert,容器,list,push,include
来源： https://blog.csdn.net/weixin_41558261/article/details/117548483

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。