程序设计基础

0、C++中常用STL库函数

STL常用库函数

#include<algorithm>

sort(s.begin(), s.end(), 自己定义)；//不稳定排序
stable_sort(v1.begin(), v1.end(), comp);     //稳定排序
binary_search(v1.begin(), v1.end(), elem);  //数组已排序，返回是否找到
upper_bound(a.begin(), a.end(), 3) - a.begin();//upper严格大于第一个元素
lower_bound(a.begin(), a.end(), 3) - a.begin();//lower是大于等于第一个元素

reverse(s.begin(),s.end());//反转
int m = unique(s.begin(), s.end()) - s.begin();//删除重复元素，m为size()
s.erase(unique(s.begin(), s.end()), s.end());//删除掉后面多余元素
srand(time(0));random_shuffle(s.begin(), s.end());//随机打乱

count(s.begin(), s.end(), '1');//计数器迭代

iter = find(v1.begin(), v1.end(), elem);    //查找等于elem的元素
iter = search(v1.begin(), v1.end(), v2.begin(), v2.end());    //在v1中查找是否有区间包含v2，若没找到，返回v1.end()

#include<string>
//一定程度上代替KMP算法
s.find(p,position)//在s中从position寻找p，返回第一个下标。注意找不到的话返回s.npos
s.rfind(p)//反向，最后一个p位置下标
s.find_first_of(p,position)//在s中从position寻找p中任意字符位置全部下标。
s.find_first_not_of(p,position)//在s中从position寻找p中第一个不匹配的位置

1、string字符串

c++

#include <string>

string s1 = "hello";

s1.clear();     //清空
s1.size();   //返回字符串长度，与下一行效果相同（不计'\0'）
s1.length();
s1.empty();  //是否为空

s1.c_str();      //返回const char*形式
s1.substr(0, s1.size());     //返回指定区间内的子串，深拷贝
s1.append(s2, 0, s2.size());    //字符串后接另一个字符串的某个区间

to_string(100);     //数值型转字符串
stoi("100");    //字符串转整型
stod("0.1");     //字符串转浮点型

python

str()#int转字符串
int()#字符串转int

2、vector和python列表

c++

vector中的函数

#include<vector>

vector<int> result;//创建
vector<int> result(n,初始值);
vector<int> v1 = {0,1,2,3};
vector<int> v1(v2.begin(), v2.end());
vector<int> v1(r, vector<int>(c, 0))  //初始化r行c列全为0的矩阵

typedef pair<int, int> PII;
vector<PII> v1;//创建两个变量的vector

v1.clear();     //清空
v1.size();   //返回元素数量
v1.empty();  //是否为空

result.front();//首部
result.back();//尾部
result.push_back(input);//压入
result.pop_back();//弹出元素
for(auto i: result)   cout<<i<<ends;//输出全部元素
 
iter = v1.insert(v1.begin(), 100);  //在vector最前面插入100

python

python列表中的函数

result = []#创建数组

len(result)#返回数组长度
result.count(name)#计数
result.append(input)#压入元素
result.pop()#弹出元素
result.extend(list)#后面接新的列表
result.sort(key=None, reverse=False)#数组排序
result = "".join(result)#转字符串

3、unordered_map/map和字典

c++

unordered_map用法

//基于红黑树实现，依据key自动排序，插入O(logn)，查找O(logn)，删除O(logn)
//也导致无法直接修改map中的元素，只能先删除再插入
#include <map>

map<int, string> m1 = {{2015, "Tom"}, {2016, "Jim"}};   //构造函数

m1.clear();   //清空
m1.size();   //返回元素数量
m1.empty();  //是否为空

m1.at[2015] = "Tom";    //取值，会检查key是否存在
m1[2015] = "Tom";   //若key存在则修改value，若不存在则创建

m1.count(key);     //返回相应key的count，可以用于判断map中是否存在该key
iter = m1.find(key);   //返回指向key的迭代器，用"!=m1.end()"判断是否找到
c1.lower_bound(key);   //返回指向首个不小于key的迭代器
c1.upper_bound(key);   //返回指向首个大于key的迭代器

m1.insert(make_pair(2015, "Tom"));  //使用pair插入
m1.insert(pair<int, string>(2015, "Tom"));
m1.insert({2015, "Tom"});   //initializer_list插入
m1.erase(key);  //返回被移除的元素的数量
m1.erase(iter);  //清除iter指向的元素
m1.erase(m1.begin()+2, m1.begin()+5);   //清除某个区间

//基于哈希表实现，插入O(n)，查找O(n)，删除O(n)
//代价占用内存比map/multimap略大一点点，内部元素不排序
#include <unordered_map>

//大部分函数同map/multimap
//由于内部元素不排序，不能使用lower_bound和upper_bound

unordered_map<int, int> occ;//创建map
occ[key] = value;//压入元素
if(auto temp = occ.find(key) == occ.end())//判断key是否在1
if(occ.count(key));//判断key是否在2
iter.first,iter.second//输出元素 

python

字典具体函数

occ = dict()# - 创建字典：`
occ[key] = value# - 压入元素：`
if key in occ:# - 判断key是否在：`

4、unordered_set/set和集合

c++

unordered_set用法

//基于红黑树实现，有自动排序，插入O(logn)，查找O(logn)，删除O(logn)
//也导致无法直接修改set中的元素，只能先删除再插入
#include <set>
#include <multiset>

set<int, less<int>> c1(c2);  //深拷贝构造
set<int, less<int>> c1(c2.begin(), c2.end());
set<int, less<int>> c1(c2.begin(), c2.end(), comp);     //迭代器返回的元素依次排序

c1.clear();   //清空
c1.size();   //返回元素数量
c1.empty();  //是否为空

c1.count(elem);  //返回elem的count，可以用于判断set中是否有elem
c1.find(elem);   //返回指向elem的迭代器，用"!=c1.end()"判断是否找到
c1.lower_bound(elem);   //返回指向首个不小于elem的迭代器
c1.upper_bound(elem);   //返回指向首个大于elem的迭代器

c1.insert(elem);    //插入单个elem
c1.insert(c2.begin(), c2.end());    //插入另一个set的某个区间
c1.erase(elem);  //返回被移除的元素的数量
c1.erase(iter);  //清除iter指向的元素
c1.erase(c1.begin()+2, c1.begin()+5);   //清除某个区间

//基于哈希表实现，插入O(n)，查找O(n)，删除O(n)
//代价占用内存比set/multiset略大一点点，内部元素不排序
#include <unordered_set>
//大部分函数同set/multiset
//由于内部元素不排序，不能使用lower_bound和upper_bound
unordered_set<char> occ;//创建
occ.insert(name);//压入元素
occ.erase(name);//擦除元素
if(auto temp = occ.find(name) == occ.end())//判断是否在1
occ.count(name)//判断是否在2：`

python

set用法

occ = set()# - 创建：`
occ.add(name)# - 压入元素：`
occ.remove(name)# - 擦除元素：`
if name in occ:# - 判断是否在：`

5、Stack

C++

#include <stack>

s1.clear();     //清空
s1.size();   //返回元素数量
s1.empty();  //是否为空

s1.top();    //返回栈顶元素

s1.push(100);  //压栈
s1.pop();  //弹栈

6、queue/deque

C++

#include <queue>
#include <deque>

q1.clear();     //清空
q1.size();   //返回元素数量
q1.empty();  //是否为空

q1.front();    //返回第一个元素
q1.back();   //返回最后一个元素

q1.push_front(100);  //首位插入100
q1.push_back(100);  //末位插入100
q1.pop_front();  //弹出第一个元素
q1.pop_back();  //弹出最后一个元素

7、优先级队列

C++

//使用堆实现，建堆O(n)，插入O(logn)，删除O(logn)，查找同vector
#include <queue>

priority_queue<int, vector<int>, less<int>> maxQ;   //大顶堆
priority_queue<int, vector<int>, greater<int>> minQ;    //小顶堆
priority_queue<int> q1(less<int>(), v1);    //用v1初始化大顶堆

q1.clear();     //清空
q1.size();   //返回元素数量
q1.empty();  //是否为空

q1.top();    //返回堆顶元素

q1.push(100);  //压入堆
q1.pop();  //弹出堆顶

//自定义比较函数Comp类的写法
struct CompLess {
    bool operator() (const int a, const int b) {
        return a < b;
    }
};

//另一种建heap的方式
#include <algorithm>
std::make_heap(v.begin(), v.end(), comp);   //建最大堆，v.front()为最大元素

v.push_back(6);
std::push_heap(v.begin(), v.end());  //其他部分为最大堆，末尾元素为新插入，进行上滤

std::pop_heap(v.begin(), v.end(), comp);    //堆顶与堆底交换，然后下滤
v.pop_back()

8、List双链表

C++

list<int> l1 = l2;  //深拷贝构造
list<int> l1 = {0,1,2,3};  //initializer_list初始化
list<int> l1(l2.begin(), l2.end());  
list<int> l1(7);  //初始化有7个元素的list
list<int> l1(7, 3)    //初始化有7个3的list

l1.clear();     //清空
l1.size();   //返回元素数量
l1.empty();  //是否为空

l1.front();     //访问第一个元素
l1.back();      //访问最后一个元素

l1.push_back(100);  //末尾插入元素
l1.pop_back();  //清除末尾元素

iter = l1.insert(l1.begin(), 100);  //在vector最前面插入100
iter = l1.insert(l1.begin(), l2.begin(), l2.end());  //插入另一个数组
iter = l1.erase(l1.begin()+2);  //erase一个数
iter = l1.erase(l1.begin()+2, l1.begin()+5);    //erase一个区间

函数内定义函数（sort为例）

• c++不允许函数内定义函数，实在想调用需要用lambda来匿名：
  lambda的c++描述
  例1：sort(idx1.begin(),idx1.end(),[&](int i, int j){return nums1[i] < nums2[j];});//引用传递比值传递[=]快很多
  例2：auto display = [&](int a,int b){return i < j}; sort(idx1.begin(),idx1.end(),display);
• python直接def即可。

Last、c++导出错误

try{  }catch(exception e){}