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

原创 2018年04月15日 20:46:16
/*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 函数,判断入队和出对的优先队列是否为空
*/

C++ STL 基本容器使用

C++ STL 基本容器使用 一、STL简介 STL(Standard Template Library),即标准模板库,是一个具有工业强度的,高效的C++程序库。它被容纳于C++标准程序(C++...
  • qq_34264472
  • qq_34264472
  • 2016-11-02 19:32:58
  • 256

【菜鸟er】STL专题_vector

/*vector vector(向量): 通俗解释:一个动态数组(随意更改大小),在不知道规模的输入下常常申请的一种数据结构(类) 使用方法: 头文件#include &amp;l...
  • F_zmmfs
  • F_zmmfs
  • 2018-03-17 12:58:29
  • 11

【菜鸟er】STL专题_优先队列

/** 优先队列: 插入一个数值+获得一个最值(获得+删除) 实现原理:堆结构 stl: priority_queue push():插入数值 pop():删除最值 top();获取最值 重点: ...
  • F_zmmfs
  • F_zmmfs
  • 2018-04-15 17:48:18
  • 1

【菜鸟er】STL专题_deque

#include &amp;lt;bits/stdc++.h&amp;gt; using namespace std; void print(int num) { cout &amp;lt;&...
  • F_zmmfs
  • F_zmmfs
  • 2018-04-15 20:34:59
  • 4

【菜鸟er】STL专题_set-multiset-map-multimap

//set应用 #include &amp;lt;bits/stdc++.h&amp;gt; using namespace std; int main() { ///1. 初始化 s...
  • F_zmmfs
  • F_zmmfs
  • 2018-04-15 20:42:21
  • 3

C++ STL(竞赛常用部分)

haha
  • ccDLlyy
  • ccDLlyy
  • 2016-11-21 21:51:48
  • 1112

acm c++常用函数(stl)

| 全排列函数next_permutation STL 中专门用于排列的函数(可以处理存在重复数据集的排列问题) 头文件:#include using namespace std; 调用: next...
  • chencsmat
  • chencsmat
  • 2015-08-19 12:22:08
  • 1823

c++STL中常用模板常用函数记录(新手向)

vector(不定长数组/向量): #include  vector vec; vector[0];//使用下标访问元素; vec.front();//取vec中的第一个元素; vec.back()...
  • nefu2015214119
  • nefu2015214119
  • 2016-02-24 12:55:17
  • 2649

STL---对STL中的各类常用函数的小总结

对STL的优先队列,map,set的小总结,望指正。
  • u013486360
  • u013486360
  • 2014-08-09 09:55:52
  • 1773

stl常用函数总结

  • 2011年10月12日 08:37
  • 1.08MB
  • 下载
收藏助手
不良信息举报
您举报文章:【菜鸟er】STL专题_容器常用函数
举报原因:
原因补充:

(最多只允许输入30个字)