【菜鸟er】STL专题_容器常用函数

/*vector
	
		vector（向量）：
			通俗解释：一个动态数组（随意更改大小），在不知道规模的输入下常常申请的一种数据结构（类）
			使用方法：
				头文件#include <vector>
				申请空间：vector <int> a;(一维数组)
						  vector<vector<int>> a;(二维数组)
						  vector <int> a_x;//作为a的元素
						  或者：vector <int*> v1;  
				表示方法：a[0],a[1];
				常用函数：
					1.push_back   在数组的最后添加一个数据
					2.pop_back    去掉数组的最后一个数据 
					3.at                得到编号位置的数据
					4.begin           得到数组头的指针
					5.end             得到数组的最后一个单元+1的指针
					6．front        得到数组头的引用
					7.back            得到数组的最后一个单元的引用
					8.max_size     得到vector的大小
					9.capacity       当前vector分配的大小
					10.size           当前使用数据的大小
					11.resize         改变当前使用数据的大小，如果它比当前使用的大，者填充默认值
					12.reserve      改变当前vecotr所分配空间的大小
					13.erase         删除指针指向的数据项
					14.clear          清空当前的vector
					15.rbegin        将vector反转后的开始指针返回(其实就是原来的end-1)
					16.rend          将vector反转构的结束指针返回(其实就是原来的begin-1)
					17.empty        判断vector是否为空
					18.swap         与另一个vector交换数据
					
					用法： vector <int> c;
				 c.clear()         移除容器中所有数据。
				 c.empty()         判断容器是否为空。
				 c.erase(pos)        删除pos位置的数据
				 c.erase(beg,end) 删除[beg,end)区间的数据
				 c.front()         传回第一个数据。
				 c.insert(pos,elem)  在pos位置插入一个elem拷贝
				 c.pop_back()     删除最后一个数据。
				 c.push_back(elem) 在尾部加入一个数据。
				 c.resize(num)     重新设置该容器的大小
				 c.size()         回容器中实际数据的个数。
				 c.begin()           返回指向容器第一个元素的迭代器
				 c.end()             返回指向容器最后一个元素的迭代器 
				 补充：
					a.at(idx);  //返回索引idx所指的数据，如果idx越界，抛出out_of_range。
					a[idx];  //返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错。
					reverse(vec.begin(),vec.end());将元素翻转，即逆序排列！
						 
*/
/*deque
	deque:双端数组
		特点：
			1.deque在接口上和vector非常相似，在许多操作的地方可以直接替换。
			2.deque可以随机存取元素支持索引值直接存取， 用[]操作符或at()方法
			3.deque头部和尾部添加或移除元素都非常快速。
			  但是在中部安插元素或移除元素比较费时。
		用法：
			声明：deque <int>  a;
			操作：
				deque的各项操作只有两点和vector不同：
					deque不提供容量操作：capacity()和reverse()。
					deque直接提供函数完成首尾元素的插入和删除。
			函数：
				deque.push_back(elem); //在容器尾部添加一个数据
				deque.push_front(elem); //在容器头部插入一个数据
				deque.pop_back();     //删除容器最后一个数据
				deque.pop_front(); //删除容器第一个数据
			
*/
/*list
	list：双向链表
		介绍：list是一个线性双向链表结构
			缺点：搜索
			优点：插入，删除
		特点：
		(1) 不使用连续的内存空间这样可以随意地进行动态操作；
		(2) 可以在内部任何位置快速地插入或删除，
				当然也可以在两端进行push 和pop 。
		(3) 不能进行内部的随机访问，即不支持[ ] 操作符和vector.at() ；
			a.begin()+2也不被允许；
		(4) 相对于verctor 占用更多的内存。
		
		
		操作：
		1.创建并赋值
			//第一种，通过构造函数
			int myints[] = {75,23,65,42,13};
			list<int> mylist1(myints, myints+5);//现成的数组
			list<int> mylist2(2,100);         // 2个值为100的元素
			
			//第二种，用push_back，或push_front
			for (int i = 1; i <= 5; ++i) mylist1.push_back(i);
			mylist2.push_front (200);
			mylist2.push_front (300);
			
			//第三种,用assign
			list<int> first;
			list<int> second;
			first.assign(7,100);                       // 给first添加7个值为100的元素
			second.assign(first.begin(), first.end()); // 复制first给second
			int myints[] = {16, 8, 4};
			first.assign (myints, myints + 3);         // 将数组myints的内容添加给first

			//第四种，见insert函数
		
		2.输出
			int myints[] = {75,23,65,42,13};
			list<int> mylist (myints,myints+5);
			//这是正序输出：
			for (list<int>::iterator it = mylist.begin(); it != mylist.end(); ++it)
				cout << ' ' << *it;
			cout << '\n';
			
			//逆序输出：
			
			for (list<int>::reverse_iterator rit = mylist.rbegin(); rit != mylist.rend(); ++rit)
				cout << ' ' << *rit;
			cout << '\n';
			
				iterator begin();  //返回指向第一个元素的迭代器
				iterator end();  //返回指向最后一个元素的迭代器
				reverse_iterator rbegin();  //返回指向第一个元素的逆向迭代器
				reverse_iterator rend();  //返回指向最后一个元素的逆向迭代器
		3.容量
			empty()
			size()
			max_size()
		4.引用
			front()
			back()
			
		5.增加 删除
				push_front();
				pop_front();
				push_back();
				pop_back();
				
				erase(p);//删除迭代器p指向的值，也可以不用变量接收其返回值
				erase(i,j);//删除[i, j)中的值，也可以不用变量接收其返回值
				
		6.其他
			resize  //调整list大小
			clear  //清空list
			swap  //交换两个list
		
		
		高级操作：
		1.splice  //将一个list中的值移到另一个list中
		
			1.1完全移动
			void splice (iterator position, list& x);  
			//将列表x中的所有元素移到当前list中，
			从当前列表的position指向的位置开始，此时列表x为空
			
			1.2单个移动
			void splice (iterator position, list& x, iterator i);  
			//将列表x中迭代器 i 指向的元素移到当前list的position指向的位置处，
			由于i指向的元素从列表x中被移除，所以迭代器 i 此时是invalid的；
			position是当前列表的迭代器，i是列表x的迭代器
			
			
			1.3区间移动
			void splice (iterator position, list& x, iterator first, iterator last);  
			//将列表x中[first, last)的元素移到当前list中，
			从position指向的位置开始；first, last是列表x的迭代器
		
			
		2.get_allocator  //返回一个跟该list有关的分配器对象	
		
*/

/*set
	set:快速查找，无重复元素
	特点：
	1.输入用 insert()
	2.输入即排序
	3..lower_bound(x);
	4.set容器不提供下标操作符
	5.	Set容器和其他容器差不多，无非就是相同的值不存，存进去自动排序好了。
*/

/*multiset
	multiset 可重复有序集合
	特点：
		1.multiset和set的唯一区别在于multiset允许键值重复
*/

/*map
	map: 一对一关系，有序。
	
	用法：
	1.声明： map<int ,string> mapStudent;
		注意 <1,2> 1叫关键字 2就称为数据好了
	2.插入数据：
		2.1 pair大法
			mapStudent.insert( pair<int, string>(1, “student_one”) );
			或者 pairs.insert(make_pair(15,99.3));//make_pair生成pair对象

		2.2 value_type数据
			 mapStudent.insert(map<int, string>::value_type (1, “student_one”));
		2.3 数组
			mapStudent[1] =  "student_one";
	3.size()函数
	4.遍历 
		循环迭代器
		用for_each
			
		数组		cout<<mapStudent[i]<<end;
		
			注：输出一对
				 Cout<< iter.first <<”   ”<< iter.second <<end;
	5.查找（包括判断关键字是否存在）
		5.1 count函数
			缺点是无法定位数据出现位置
		5.2 find函数
			返回的一个迭代器，当数据出现时，它返回数据所在位置的迭代器，
			如果map中没有要查找的数据，它返回的迭代器等于end函数返回的迭代器
		5.3
			Lower_bound函数用法，这个函数用来返回要查找关键字的下界(是一个迭代器)
			Upper_bound函数用法，这个函数用来返回要查找关键字的上界(是一个迭代器)
	6.	clear()函数 empty()函数	
	7.erase函数
		7.1用迭代器删除 mapStudent.erase(iter);
		7.2用关键字删除 int n = mapStudent.erase(1);//如果删除了会返回1，否则返回0
		
			
*/

/*multimap
	一对一映射，可有重复元素
	与map的不同之处：
		1.包含重复key
		2.multimap 中去掉下标操作符
		3.查找
			3.1
				find(k) 返回指向第一个与键 k 匹配的 pair 的迭代指针，
				这就是说，当你想要检查是否存在至少一个与该键关联的值时，
				或者只需第一个匹配时，这个函数最有用。
			3.2	equal_range(k)：该函数查找所有与 k 关联的值。
				返回迭代指针的 pair，它标记开始和结束范围。
					举例：typedef pair<CIT, CIT>  P;
							P range = dns.equal_range("213.108.96.7");
			3.3 lower_bound() 和 upper_bound()
			
*/

/*stack
	栈
		pop() 移除栈顶元素
		push() 在栈顶增加元素
		top() 返回栈顶元素
*/
/*queue
	队
		push()队尾添加
		pop()队首弹出
		front()访问队首
		back()访问队尾
*/
/*priority_queue
	优先队列 ：   ①插入一个数值    ②取出最大(或者最小)的数值(获取数值，并且删除)。
	heap（堆）实现的；
	
	特点：
		一端入队，一端出队。
		队列中最大的元素总是位于队首位置
		priority_queue 优先队列容器也不提供迭代器
		入队函数也是 push 函数
		出队函数为 pop 函数，一般要先判断队列不为空，才进行元素出队操作
		top 函数，可用来读取队首元素，即优先级最高的元素
		empty 函数，判断入队和出对的优先队列是否为空
*/