C++ map、vector、pair

只写一些简单的应用，用于写题

map

$map$是一对一的
第一个可以称为关键字$(key)$，每个关键字只能在$map$中出现一次
可以用于离散化
第二个可以称为该关键字的值$(value)$

构造

$map<A,B>C$
$A、B$ 是关键字的类型，如$int、string、double、pair$< >等
$C$ 是$map$的名字
其实可以把$map$当成数组用
这个数组可以用于离散化、多用于数组内数字数量不确定

插入

方法1

map<A, B> C
C.insert(pair<A, B>(A类型的值, B类型的值));
C.insert(make_pair(A类型的值, B类型的值));

#EG · 加入一个单词sunny到11号位置
map<int, string> h;
h.insert(pair<int, string>(11, "sunny"));
h.insert(make_pair(11, "sunny"));

方法2

map<A, B> C
C[A类型的值] = B类型的值;

#EG · 加入一个单词sunny到11号位置
map<int, string> h;
h[11] = "sunny";

两者有一定区别，后者可以完成覆盖操作前者不行

#EG · 如果要把sunny变成windy
h.insert(pair<int, string>(11, "windy"));//h[11]中仍然是sunny
h[11] = "windy";//h[11]为windy

查找

方法1

B 变量 = C.find(A类型的值);

#EG · 取出11号位置里的值
map<int, string>::iterator  x;  
x = h.find("11");//括号中如果为int，需要加双引号
结果：x == "sunny"//假设我们上面没有覆盖上windy

方法2

B 变量 = C[A类型的值];

#EG · 取出11号位置里的值
string x = h[11];
结果：x == "sunny"//假设我们上面没有覆盖上windy

刪除与清空

删除的方法1

指针 = C.find(A类型的值);
C.erase(变量)

#EG · 删除11号里的值
map<int, string>::iterator  x;  
x = h.find("11");
h.erase(x);

删除的方法2

bool/int 变量 = C.erase(A类型的值);//如果刪除了会返回1，否则返回0

#EG · 删除11号里的值
h.erase("11"); 

清空

C.erase(C.begin(), C.end());
或者C.clear(）;

#EG · 清空h
h.erase(h.begin(), h.end());
或者 h.clear();

大小

int 变量 = C.size();//返回所有元素总共出现个数
int 变量 = C.count(B类型的值)//返回指定元素出现的次数

#EG · 记录h的大小
int size1 = h.size();
#EG · 记录h中值为windy的个数
int size2 = h.count("windy");

输出

1

begin()   返回指向map头部的迭代器
end()     返回指向map末尾的迭代器

#EG · 从前往后输出
map<int, string>::iterator  z;  
for(z = h.begin(); z != h.end(); z++)  
   cout<<z->first<<"   "<<z->second<<endl;  

2

rbegin()  返回一个指向map尾部的逆向迭代器
rend()    返回一个指向map头部的逆向迭代器

#EG · 从后往前输出
map<int, string>::reverse_iterator  z;  
for(z = h.rbegin(); z != h.rend(); z++)  
   cout<<z->first<<"   "<<z->second<<endl;

其他基本操作函数：

注释掉的函数，平时做题基本用不上
   lower_bound()  返回键值>=给定元素的第一个位置
   upper_bound()  返回键值>给定元素的第一个位置
   equal_range()  返回一个pair，第一个变量是lower_bound返回的迭代器，第二个是upper_bound返回的迭代器
   value_comp()   返回比较元素value的函数
   key_comp()     返回比较元素key的函数
   
   empty()        如果map为空则返回true
   swap()         交换两个map
   
   //get_allocator()  返回map的配置器
   //max_size()       返回可以容纳的最大元素个数

pair

构造与初始化

pair<T1, T2> p1;         创建一个空的pair对象，它的两个元素分别是T1和T2类型，采用值初始化。
pair<T1, T2> p1(v1, v2); 创建一个pair对象，它的两个元素分别是T1和T2类型
						 其中first成员初始化为v1，second成员初始化为v2。
pair<T1, T2> p2(p1);     拷贝初始化
创建pair对象时，必须提供两个类型名，两个对应的类型名的类型不必相同

比较

p1 < p2;    两个pair对象间的小于运算，first优先
p1 == p2；  需要first和second都相等

访问

p1.first();   取出p1中first的值
p1.second();  取出p1中second的值

生成新的pair对象

make_pair(v1, v2);   以v1和v2的值创建一个新的pair对象，其元素类型分别是v1和v2的类型。

vector

动态数组，严格的线性顺序排序

构造

vector<类型>标识符
vector<类型>标识符(最大容量)
vector<类型>标识符(最大容量,初始所有值)
vector< vector< int> > A; 还可以构造二维向量

函数

vector<int> A;
vector<int> B;
int x, z;
bool p;
iterator y;

# EG 在数组的最后添加一个数据 
A.push_back(x); 
# EG 去掉数组的最后一个数据
A.pop_back(); 
# EG 得到编号位置的数据
x = A.at() 
# EG 得到数组头的指针
y = A.begin(); 
# EG 得到数组的最后一个单元+1的指针
y = A.end(); 
# EG 得到数组头的引用
x = A.front(); 
# EG 得到数组的最后一个单元的引用
x = A.back(); 
# EG 得到vector最大可以是多大
z = A.max_size(); 
# EG  当前vector分配的大小
z = A.capacity(); 
# EG 容器中实际数据个数 
z = A.size(); 
# EG 删除指针指向的数据项
A.erase(y); 
# EG 清空当前的vector
A.clear(); 
# EG 将vector反转后的开始指针返回(其实就是原来的end-1)
y = A.rbegin(); 
# EG 将vector反转构的结束指针返回(其实就是原来的begin-1)
y = A.rend(); 
# EG  判断vector是否为空
p = A.empty();
# EG 与另一个vector交换数据
swap(A, B); 
# EG 排序
sort(A.begin(),A.end());从小到大
reverse(A.begin(),A.end());从大到小 

输出

vector<int> A;
for(int i = 0; i < A.size(); i++)
	cout<<A[i]<<" ";

vector<int>::iterator it;//声明一个迭代器
for(it = A.begin(); it != A.end(); it++)
    cout<<*it<<" ";

while(!A.empty()) {
	int x = A.front();
	A.pop();
	cout<<x<<" ";
}