STL迭代器

STL

1. vector(容器)

头文件: #include<vector>

vector是变长数组(可以自定义改变长度的数组)

vector a; //一个长度动态变化的int 数组

vector b[233]; //相当于第一维数组长233，第二位长度动态变化的int数组

保存int的迭代器声明方法;

vector<int>::iterator it = a.begin();

it 相当于a[0] it + 2 相当于a[2]

想取值的话 *it;

a.size() ;  //函数返回vector的实际长度
a.empty(); //判断数组是不是空的 是空的返回true 反之false
a.clear();  //把当前的数组清空 删完后数组中只有0个元素
a.begin(); // 第一个元素地址  
a.end();  //最后一个元素的地址
[begin,end） [begin,back] 
a.push_back(x);//在最后添加一个数x;
a.pop_back();//删除最后一个数

三遍历方式：

	//普通遍历
	for (int i = 0; i < a.size(); i++)
		cout << a[i] << ' '; cout << endl;
	//迭代器遍历
	for (vector <int>::iterator i = a.begin(); i != a.end(); i++)
         //也可写为for (auto i = a.begin; i != a.end(); i++)
		cout << *i << ' '; cout << endl;
	//范围遍历
	for (int x : a)
		cout << x << ' '; cout << endl;

小总结

cout << a.front() << ' ' << a[0] << ' ' << * a.begin() << endl; //输出的第一个值相同
cout << a.back() << ' ' << a[a.size() - 1] <<  endl;            //输出的最后一个值相同

2.queue (队列)

头文件：#include<queue>

特点：先进先出(先存入的先弹出); //只能从队头弹出 队伍插入

包括：

1. queue 循环队列

2. priority_queue 优先队列 (需要重载)

声明:

queue<int> q; //循环队列
struct res{- - - } ; 
queue<res> q; 
priority queue<int> q ; //优先队列的大根堆需要重载小于号
priority queue<int , vector <int>,greater<int>q; //优先队列的小根堆需要重载大于号

eg:

struct Res
{
	int a, b;
	bool operator <  (const Res & t) const  
	{
		return a < t.a;
	}
};
priority_queue<Res>  d; //此处是大根堆所以要重载小于号 既  operator 后的 < 号

循环队列:

定义方式 :  queue<int> q; 
q.push(1);//在队头插入一个元素
q.pop();//弹出队尾元素
q.front();//返回队头
q.back();//返回队伍

注意事项: 队列 ，优先队列 ，栈 都没有clear函数

但可以用初始化的方式清空队列： 既q = queue();

优先队列:

定义方式：priority_queue<int> a;
a.push(1) ; //插入一个数
a.top() //取最大值
a.pop() //删除最大值

3.stack(栈)

头文件: #include<stack> //头文件包含栈 .声明和前面的容器类似

特点:先进后出（先进的是最后弹出的） // 只能从队尾插入只能从队伍弹出

定义方式:stack<int> stk;

相关操作:

	stk.push(1); //向栈顶插入 
	stk.tap(); //返回栈顶元素
	stk.pop(); // 弹出栈顶元素

4.deque(双端队列)

特点:既可以在队头插入也可以在队尾插入同理出也可以

头文件: #include<deque>

定义方式 ： deque<int> a;

相关用法"

	a.begin(), a.end();
	a.front, a.back();

	a.push_back(1);//队后插入
	a.push_front(2); //队头插入
	a[0]; // 随机访问一个元素
	a.pop_back();//从队尾出队
	a.pop_front();//从队头出队
	a.clear(); //清空队列

5.set

头文件:#include<set>

特点： <set>中所有的元素都互不相同，并且是有序的（默认从小到大），在内部是通过二叉查找树实现，与map不同的是其关键词（key）和值（value）相等

定义方式 ：

	1.set <int> a;    为有序集合 既 元素不可以重复
	2.multiset<int> b;为有序多重集合 既 元素不能重复
	拥有迭代器 且定义方式为:
    set<int> ::iterator it = a.begin();
	可以使用 it++，it--
	        ++it，--it
	3.//因为需要比较 所以也需要重载一个 ＜ 号
	struct Res
	{
		int x, y;
		bool operator < (const Res& t) const
		{
			return x < t.x;
		}
	};

相关用法:

a.end();
a.insert(x);//插入一个x
a.find(x)   // 查找x 如果找到x 会返回x迭代器 如果没有找到会返回a.end()
      if(a.find(x) == a.end()) //可以判断x在a中是否存在
a.lower_bound(x); //找到大于等于x的最小的元素的迭代器 
a.upper_bound(x); //找到大于x的最小的元素的迭代器
a.erase(x);  //将x的所有元素删掉 如果是迭代器则删除迭代器;
a.count(x);  //x在a中的个数 

6.map

头文件 ：#include<map>

特点：

1、所有元素都会根据元素的键值自动排序

2、所有的元素都是pair,同时拥有键值和实值。 第一个参数：键值 第二个参数：实值

3、map容器的键值唯一 不可变 实值 可变。

三种定义方式及用法:

map<int, int > a;  //int， int 可以是任意类型！！！
a[1] = 2;
a[100000000] = 3;
cout << a[100000000] << endl;

map<string, int>a;
a["yxc"] = 2;
cout << a["yxc"] << endl;

map < string, vector<int>> a; 
a["yxc"] = vector<int>({ 1,2,3,4 });
cout << a["yxc"][2] << endl;

7.unordered_set(哈希表)

头文件: #include<unordered_set>

定义方式:

#include<unordered_set>
unordered_set<int> a;  //哈希表 ，不能存储重复元素	
unordered_multiset<int> b; //哈希表，可以存储重复元素

#include<unordered_map>
unordered_map<int,int> c;

相关用法： 同上。

8. bitset

头文件：#include<bitset>

定义方式及其用法：

bitset<1000> a;
bitset<100> a,b; 
//赋过值的为1 没赋过值的为0 可以做位运算
a[0] = 2;//输出会为1
	a.set(3);//将a[3] 设为1
	a.reset(3); //将a[3]设为0

pair用法
pair<int , string > a;
a = {3 , “yxc};
cout << a.first << ‘ ‘ << a.second << endl;
a = make_pair(4,”abc”);
cout << a.first << ‘ ‘ << a.second << endl;