STL介绍

1.顺序式容器

  • vector 动态数组。随机访问频繁,插入删除较少。
  • list 双向链表。插入删除频繁,随机访问较少。
  • stack 栈。先进后出。
  • queue 队列。先进先出。
  • priority_queue 优先队列。每一次的 push() 操作,优先级最高的元素都会被放在最前面。
  • deque 双向队列。
//头文件
#include <iostream>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <deque>
I.vector
std::vector<int> v;
vector功能例子说明
插入v.insert ( v.begin()+i, k )在下标为 i 处插入 k
插入末尾v.push_back ( k )在末尾插入 k
插入末尾v.insert ( v.end(), n, k )在末尾插入 n 个值为 k 的元素
删除v.erase ( v.begin() + n )删除下标为 n 的元素( 第 n+1 个)
删除末尾v.pop_back ()删除末尾元素
删除区间v.erase(v.begin()+i,v.begin()+j)删除下标 [ i, j-1 ] 的元素
查找v[ i ]访问下标为 i 的元素。直接访问任何元素
是否为空v.empty ()数组为空返回True
大小v.size ()数组大小
调整大小v.resize ( n )数组大小变为 n. 数组变小则砍掉靠后元素. 数组变大则增加0
调整大小v.resize ( n, k )末尾插入 k 使数组大小为 n
当前空间大小v.capacity ()当前系统分配的存储空间大小
调整预留空间大小v.reserve ( n )设置预留空间大小为 n
互换两个数组v1.swap ( v2 )交换两个数组的所有元素
排序sort ( v.begin(), v.end() )借用 sort() 递增排序
清空v.clear ()清空数组
逆置reverse ( v.begin(), v.end() )借用 reverse() 逆置数组
//使用迭代器做简单插入例子
#include <iostream>
#include <vector>

int main (){
	std::vector<int> myvector (3,100); //100 100 100 
	std::vector<int>::iterator it;

	it = myvector.begin();
	it = myvector.insert ( it , 200 ); //200(it) 100 100 100 

	myvector.insert (it,2,300); //300(it) 300 200 100 100 100
	//it已经失效,需要重新赋值
	it = myvector.begin(); 

	std::vector<int> anothervector (3,400); //400 400 400 
	myvector.insert (it+2,anothervector.begin(),anothervector.end()); 
	//300 300 400 400 400 200 100 100 100

	int myarray [] = { 501,502,503 };
	myvector.insert (myvector.begin(), myarray, myarray+3);
	//501 502 503 300 300 400 400 400 200 100 100 100

	std::cout << "myvector contains:";
	for (it=myvector.begin(); it<myvector.end(); it++)
    	std::cout << ' ' << *it;
	std::cout << '\n';

    return 0;
}
}
it = myvector.insert ( it , 200 );//迭代器这样写最好
myvector.insert ( it , 200 );//不要这样写
在vector中使用迭代器插入,不会改变迭代器指向的位置
而在list中使用迭代器插入,指向的位置随之向后移动使得指向的位置改变而指向值不变
II.list
std::list<int> L;

和vector的功能大同小异

III.stack
std::stack<Type> s;
stack功能例子说明
插入栈顶s.push ( item )把 item 放入栈顶
查找栈顶元素item = s.top ()返回值但是不退栈
删除栈顶元素s.pop ()退栈但是不返回值
是否为空s.empty ()栈为空返回 True
大小s.size ()栈大小
互换s1.swap ( s2 )交换两个栈的所有元素
插入栈顶s.emplace ( item )把item插入栈顶。C++11
IV.queue
std::queue<Type> q;
queue功能例子说明
插入队列q.push ( item )插入元素 item
查找队首item = q.front ()返回队首元素
查找队尾q.back ()返回队尾元素
删除队首q.pop ()删除队首但是不返回值
是否为空q.empty ()队列为空返回 True
大小q.size ()队列大小
交换q1.swap( q2 )交换两个队列的所有元素
插入队列q.emplace ( item )把item插入队列。C++11
V.priority_queue
std::priority_queue<Type> pq;
priority_queue功能例子说明
插入队列pq.push ( item )插入元素 item
查找队首item = pq.top ()返回队首元素
删除队首pq.pop ()删除队首但是不返回值
是否为空pq.empty ()队列为空返回 True
大小pq.size ()队列大小
交换pq1.swap( pq2 )交换两个队列的所有元素
插入队列pq.emplace ( item )把item插入队列。C++11

2.关联式容器

  • set 集合
  • multiset 快速查找
  • map 一对一映射
  • multimap 一对多映射
//头文件
#include <iostream>
#include <set>
#include <map>
I.set
std::set<int> s;
set功能例子说明
插入队列s.insert ( item )插入元素 item
删除元素s.erase ( item )删除元素 item
删除元素s.erase ( it )删除迭代器指向的元素
删除元素s.erase ( it1, it2 )删除两个迭代器中间的的元素,左闭右开
是否为空s.empty ()set 为空返回 True
大小s.size ()队列大小
清空s.clear ()清空 set
寻找it = s.find ( item )返回一个迭代器指向 item
s.lower_bound ( item )返回一个迭代器,指向健值大于等于item的第一个元素
s.upper_bound ( item )返回一个迭代器,指向健值大于item的第一个元素
判断存在s.count ( item )如果set中存在 item, 返回1;否则返回0
II.map
template < class Key,                                     // map::key_type
           class T,                                       // map::mapped_type
           class Compare = less<Key>,                     // map::key_compare
           class Alloc = allocator<pair<const Key,T> >    // map::allocator_type
           > class map;

map是一种关联式存储器,存储的是<key value, mapped value>对的联合体,并且有一定的排序。
通常 key 被用来排序,并且被唯一确定 map 中的元素;而 mapped value 存储内容。key 和 mapped value 一般是不同类型的数据,用 value_type 统一表示,如下所示:
typedef pair<const Key, T> value_type;
排序时,map 中的元素总是通过 key 并且按照一个特殊可自定义标准来排序,这个标准用 Compare 类的内部比较对象定义。
map 中的 mapped values 也可以直接被访问到通过重载 operator[] 来访问相关 key。
参考


特性:
关联性。关联性容器中的元素可以通过 key 来访问,而不是通过在容器中的绝对位置。
有序性。容器中的元素在任何时刻都严格有序。所有元素在插入时都会按照顺序被放在一定的位置。
内部联合。每一个元素都是一个 key 联合一个 mapped value:通过 key 来确认内容 mapped value。
key 唯一。不会有两个元素拥有相同的 key。
自定义分配。我们可以通过一个 allocator 对象来动态处理存储需要。


下面是通过小例子给出功能:

#include<iostream>
#include<map>
using namespace std;
int main (){
	std::map<int, char> student; //存储学生的ID和性别
	//插入
	student.insert( std::pair<int, char>(1,'M'));//通过insert插入 
	student.insert( std::pair<int, char>(2,'F'));
	student[3] = 'M';//通过key插入 
	student[4] = 'F';
	student[5] = 'M';
	student[6] = 'F';
	student[7] = 'M';
	student[8] = 'F';
	
	//删除
	student.erase(5);//通过key删除 
	std::map<int, char>::iterator it = student.find(6);
	student.erase(it);//通过迭代器it删除
	it = student.find(7);
	student.erase(it, student.end());//通过范围删除
	
	//查询
	for(it=student.begin(); it!=student.end(); it++)
		std::cout<<it->first<<"=>"<<it->second<<'\n';//通过迭代器查询 
	std::cout<<student[2]<<'\n'; //通过key查询 
	std::cout<<'\n';
	int id = student.find(1)->first;//通过find()查询 
	char sex = student.find(1)->second;
	
	//大小
	int len = student.size();
	
	//是否为空
	bool emp = student.empty();
	
	//查询是否存在某个元素 
	bool exist = student.count(3); //通过key查询
	
	//插入emplace.C++11
//	student.emplace('5','M');
//	student.emplace('6','F');
	
	//从后往前
	std::map<int, char>::reverse_iterator rit;
	for(rit=student.rbegin(); rit!=student.rend(); rit++)
		std::cout<< rit->first <<"=>"<< rit->second <<'\n'; 
	std::cout<<'\n';
	
	//按照key排序,第三个参数控制。默认是less<Key>就是升序。greater<>就是降序 
	std::map<int, char, greater<int> > man;
	man[5] = 'F';
	man[1] = 'F';
	man[2] = 'F';
	man[4] = 'M';
	man[3] = 'F'; 
	for(it=man.begin(); it!=man.end(); it++)
		std::cout<<it->first<<"=>"<<it->second<<'\n';
	std::cout<<'\n';
	
	//交换swap.排序不一样不能交换
	std::map<int, char> worker;
	worker[10]='a';worker[11]='b';worker[12]='c';
	student.swap(worker);
	std::cout << "student contains:\n";
	for(it=student.begin(); it!=student.end(); it++)
		std::cout<<it->first<<"=>"<<it->second<<'\n';
	std::cout << "worker contains:\n";
	for(it=worker.begin(); it!=worker.end(); it++)
		std::cout<<it->first<<"=>"<<it->second<<'\n';
	std::cout<<'\n';
	student.swap(worker);
	
	//key_comp()比较两个参数顺序是否符合map的顺序。符合返回true 
	std::map<int, char>::key_compare studentkey_comp = student.key_comp(); 
	it = student.begin();//<1,M>
	do{
		std::cout<<it->first<<" "<<it->second<<'\n'; //输出前三个 
	}while( studentkey_comp( (*it++).first, student.find(3)->first ) );
	std::cout<<'\n';
	
	//value_comp()整体比较 
	std::pair<int, char> last = *student.rbegin()++;
	it = student.begin();
	do{
		std::cout<<it->first<<"=>"<<it->second<<'\n'; 
	}while( student.value_comp()(*it++, last) );
	std::cout<<'\n';
	
	//清空map
	student.clear();
	
	return 0;
}
  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

正在学C++

2角不嫌多,1角不嫌少

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值