C++的各种模板

C++的各种模板

优先队列 #include <\queue>

定义

1. 默认定义—例如priority_queue d;
   priority_queue<vector, less > pq1;默认递增排序，最大堆
   priority_queue<vector, greater > pq1;递减排序，最小堆

2. 自定义 priority_queue<int, vector, cmp> q;

struct cmp {     
　　operator bool ()(int x, int y)     
　　{        
　　　　 return　x > y;　　 // x小的优先级高 表示最小堆
　　　　 //也可以写成其他方式，如： return p[x] > p[y];表示p[i]小的优先级高
　　}
};

3. 自定义结构体：priority_queueq;

struct node {     
　　int x, y;     
　　friend bool operator < (node a, node b)     
　　{         
　　　　return a.x > b.x;    //结构体中，x小的优先级高 表示最小堆
　　}
};

操作

empty() 　　 如果队列为空，则返回真
pop()　　　　删除对顶元素，删除第一个元素
push() 　　 加入一个元素
size() 　　　 返回优先队列中拥有的元素个数
top() 　　　　返回优先队列对顶元素，返回优先队列中有最高优先级的元素

模板 #include <\vector>

定义 例如——vectorE[MAXN]定义了一个图的边

vector<int> a ;                           //声明一个int型向量a
    vector<int> a(10) ;                    //声明一个初始大小为10的向量
    vector<int> a(10, 1) ;                //声明一个初始大小为10且初始值都为1的向量
    vector<int> b(a) ;                      //声明并用向量a初始化向量b
    vector<int> b(a.begin(), a.begin()+3) ;  
    					//将a向量中从第0个到第2个(共3个)作为向量b的初始值
    int n[] = {1, 2, 3, 4, 5} ;
    vector<int> a(n, n+5) ;              //将数组n的前5个元素作为向量a的初值
    vector<int> a(&n[1], &n[4]) ;        //将n[1] - n[4]范围内的元素作为向量a的初值

操作 vector ；

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()             	返回指向容器最后一个元素的迭代器

函数模板 #include algorithm

sort函数：默认从小到大
自定义结构体排序时，当返回值为1时，参数在前的排序在前
例：算凸包时对排序定义：当满足if条件时返回1，a参数排在b前面

bool cmp(const points &a,const points &b){
    double temp=cross(a,b,point[0]);
    if(temp>0||(temp==0&&dis(a,point[0])<dis(b,point[0])))
        return 1;
    return 0;
}
sort(point+1,point+N,cmp);

 lower_bound( )和upper_bound( )函数

基本用法

• lower_bound( begin,end,num)：
  从数组的begin位置到end-1位置二分查找第一个大于或等于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

• upper_bound( begin,end,num）：
  从数组的begin位置到end-1位置二分查找第一个大于num的数字
  例：在分治——路由器安置问题中有运用upper_bound(h+1,h+N+1,h[temp]+d)-h;得到第一个超出路由器范围的地址。

• greater</type/>()
  计算从大到小排列的数组

自定义

bool compare(type a, type b)
 {return a>b;}
lower_bound(迭代器_1, 迭代器_2, x, compare)
struct cmp_lower	//lower_bound
{
    bool operator  () (int index,int x)
    {
        return l[index]<x;
    }
};
struct cmp_upper		//upper_bound
{
    bool operator  () (int x,int index)
    {
        return x<l[index];
    }
};

reverse()会将区间[beg,end)内的元素全部逆序； 

复数模板 #include /complex

complex<float>、complex<double>、complex<long double>
实数部分real()，虚数部分imag；
complex z = 5.0 + 3i; // z is now complex<double>{5, 3}

map #include map

• 构造:
  // 定义一个map对象
  map<int, string> mapStudent;
  // 第一种 用insert函數插入pair
  mapStudent.insert(pair<int, string>(000, “student_zero”));
  // 第二种 用insert函数插入value_type数据
  mapStudent.insert(map<int, string>::value_type(001, “student_one”));
  // 第三种 用"array"方式插入
  mapStudent[123] = “student_first”;
  mapStudent[456] = “student_second”;

• 元素插入：
  m.insert(e);// e是一个pair类型对象
  m.insert(b, e);// b和e分别是迭代器的开始和结束位置
  map中的key是唯一的。
  当使用insert方法插入已经存在的Key值时，不能成功插入，也就是不会覆盖原来的键值；
  而使用[]方式插入已经存在的Key值时，会用新的key-value覆盖原来的值。

• 排序
  和sort一样，默认是第一个关键字从小到大排，可以修改排序方式；
  从大到小map<string, int, greater > mapStudent;
  修改比较函数：

   struct CmpByKeyLength{  
   	bool operator()(const string& k1, const string& k2) {  
   		return k1.length() < k2.length();  
   	}  
   }；
   map<string, int, CmpByKeyLength > mapStudent;  
  

修改结构体内比较运算符:

typedef struct tagStudentInfo  {      
	int iID;      
	string  strName;      
	bool operator < (tagStudentInfo const& r) const {               
		if(iID < r.iID)  return true;          
		if(iID == r.iID) return strName.compare(r.strName) < 0;         
			return false;    
		}  
}StudentInfo;
map<StudentInfo, int>mapStudent;

map的基本操作函数：
     C++ maps是一种关联式容器，包含“关键字/值”对
     begin()         返回指向map头部的迭代器
     clear(）        删除所有元素
     count()         返回指定元素出现的次数
     empty()         如果map为空则返回true
     end()           返回指向map末尾的迭代器
     equal_range()   返回特殊条目的迭代器对
     erase()         删除一个元素
     find()          查找一个元素
     get_allocator() 返回map的配置器
     insert()        插入元素
     key_comp()      返回比较元素key的函数
     lower_bound()   返回键值>=给定元素的第一个位置
     max_size()      返回可以容纳的最大元素个数
     rbegin()        返回一个指向map尾部的逆向迭代器
     rend()          返回一个指向map头部的逆向迭代器
     size()          返回map中元素的个数
     swap()           交换两个map
     upper_bound()    返回键值>给定元素的第一个位置
     value_comp()     返回比较元素value的函数

pair #include

pair<T1, T2> p1;            //创建一个空的pair对象（使用默认构造），它的两个元素分别是T1和T2类型，采用值初始化。
pair<T1, T2> p1(v1, v2);    //创建一个pair对象，它的两个元素分别是T1和T2类型，其中first成员初始化为v1，second成员初始化为v2。
make_pair(v1, v2);          // 以v1和v2的值创建一个新的pair对象，其元素类型分别是v1和v2的类型。
p1 < p2;                    // 两个pair对象间的小于运算，其定义遵循字典次序：
如 p1.first < p2.first 或者 !(p2.first < p1.first) && (p1.second < p2.second) 则返回true。
p1 == p2；                  // 如果两个对象的first和second依次相等，则这两个对象相等；该运算使用元素的==操作符。
p1.first;                   // 返回对象p1中名为first的公有数据成员
p1.second;                 // 返回对象p1中名为second的公有数据成员

list #include

list 是顺序容器的一种。list 是一个双向链表。使用 list 需要包含头文件 list。双向链表的每个元素中都有一个指针指向后一个元素，也有一个指针指向前一个元素,list 容器不支持根据下标随机存取元素。
Lst1.assign() 给list赋值
Lst1.back() 返回最后一个元素
Lst1.begin() 返回指向第一个元素的迭代器
Lst1.clear() 删除所有元素
Lst1.empty() 如果list是空的则返回true
Lst1.end() 返回末尾的迭代器
Lst1.erase() 删除一个元素
Lst1.front() 返回第一个元素
Lst1.get_allocator() 返回list的配置器
Lst1.insert() 插入一个元素到list中
Lst1.max_size() 返回list能容纳的最大元素数量
Lst1.merge() 合并两个list
Lst1.pop_back() 删除最后一个元素
Lst1.pop_front() 删除第一个元素
Lst1.push_back() 在list的末尾添加一个元素
Lst1.push_front() 在list的头部添加一个元素
Lst1.rbegin() 返回指向第一个元素的逆向迭代器
Lst1.remove() 从list删除元素
Lst1.remove_if() 按指定条件删除元素
Lst1.rend() 指向list末尾的逆向迭代器
Lst1.resize() 改变list的大小
Lst1.reverse() 把list的元素倒转
Lst1.size() 返回list中的元素个数
Lst1.sort() 给list排序
Lst1.splice() 合并两个list
Lst1.swap() 交换两个list
Lst1.unique() 删除list中重复的元素