刷OJ常用函数汇总
#include<iostream>
#include<algorithm>
#include<functional>
#include<vector>
#include<set>
#include<unordered_set>
//map中涉及pair，添加map头文件的同时会自动添加pair头文件
#include<map>
#include<unordered_map>
#include<stack>
#include<queue>
#include<deque>
#include<string>
#include<array>
#include<cstdlib>
#include<cctype>
#include<cmath>
//using namespace::some_name
using std::cout;
using std::cin;
using namespace std;
//结构体中的构造函数
//编译器默认提供无参构造函数，自定义构造函数之后，则不提供无参构造
struct student {
int id;
char gender;
string name;
//自定义无参构造，初始化成员变量
student() { id = 0; gender = 'm'; name = ""; }
student(int _id, char _gender, string _name) {
this->id = _id;
this->gender = _gender;
this->name = _name;
}
};
struct teacher {
int id;
char gender;
string name;
//自定义无参构造，初始化成员变量
teacher() { id = 0; gender = 'm'; name = ""; }
teacher(int _id,char _gender,string _name):id(_id),gender(_gender),name(_name) {}
};
void f_constant() {
//#define name_of_constant value_of_constant
#define pi 3.14
//const修饰的常量 const type_name variable
const int ci = 12;
}
void f_bit_operation() {
//1.左移 <<
cout <<"左移： 1<<3 "<< (1<<3) << endl;
//2.右移 >>
cout << "右移： 16>>3 " << (16 >> 3) << endl;
//3.按位与 &
cout << "按位与：8 & 9 " << (8 & 9)<< endl;
//4.按位或 |
cout << "按位或：8 | 9 " << (8 | 9) << endl<< endl;
//5.位异或 ^
cout << "位异或：8 ^ 9 " <<(8 ^ 9)<< endl;
//6.位取反 ~
cout << "位取反：~8 " << (~8) << endl;
}
void f_char() {
char c1;
c1 = getchar();
putchar(c1);
}
//变长数组，可随意调整数组长度，自动初始化为0，false
void f_vector() {
//初始化
vector<int> v0(10);
vector<int> v1 = { 1,2,3,4 };
vector<int> v2(10, 2);
vector<int> v3;
vector<int> v4(v1);
//常用操作
v1.push_back(1);
v1.pop_back();
auto pb = v1.begin();
auto pe = v1.end();
v1.size();
v1.resize(100);
v1.clear();
v1.empty();
v1.insert(v1.begin()+2,10);
v1.erase(v1.begin() + 3);
v1.erase(v1.begin(),v1.begin()+3);
}
//内部自动有序不含重复元素（红黑树实现）
void f_set() {
//初始化
set<int> s0;
set<int> s1 = { 1,2,3,4,5 };
set<int> s2(s1);
//常用操作
auto pb = s0.begin();
auto pe = s0.end();
s0.insert(10);//set自动去除重复元素，且自动有序（multiset可重复，unordered_set无序）
//s0.erase(s0.find(10));
auto p_tmp = s0.find(10);//p_tmp是set<int>::iterator类型
cout << *p_tmp << endl;
s0.erase(p_tmp); //依据迭代器删除单个元素
s0.erase(10); //依据元素的值删除单个元素
s0.erase(s0.begin(), s0.end());//删除迭代器指定的一串元素
s0.size();
s0.clear();
}
//map （红黑树实现）键唯一且有序,
//multimap 一个键对应多个值，
//unordered_map （散列实现）只映射不排序
void f_map() {
//初始化
map<char, int> mp;
mp['a'] = 0;
mp['b'] = 1;
mp['c'] = 2;
mp['d'] = 3;
//使用迭代器访问map
for (auto pb = mp.begin(); pb != mp.end(); pb++) {
cout << pb->first << " " << pb->second << endl;
cout << (*pb).first << " " << (*pb).second << endl;
}
//使用键访问map
cout << mp['a'] << " " << mp['b'] << mp['c'] << mp['d'] << endl;
//常用操作
auto it = mp.find('a');//find(key)返回键为key的映射的迭代器
cout << it->first << " " << it->second << endl;
mp.erase(mp.find('a'));//erase(it)，删除迭代器指定的元素
mp.erase('b');//erase(key),删除key指定的元素
mp.erase(mp.find('c'), mp.end());//erase(it1,it2),删除[it1,it2)指定的元素
cout << mp.size() << endl;
mp.clear();
}
//后进先出，只能使用top()访问栈顶元素
void f_stack() {
//初始化
stack<int> st;
for (int i = 0; i < 10; i++) {
st.push(i);
}
cout << st.top() << endl;//9
st.pop();
cout << st.top() << endl;//8
//常用操作 empty(),size()
}
void f_queue() {
//初始化
queue<int> q;
for (int i = 0; i < 10; i++) {
q.push(i); //压入队列
}
//常用操作
cout << q.front() << " " << q.back() << endl;//只访问而不删除
cout << q.size() << endl;
q.pop();//队首元素出队列
cout << q.empty() << endl;//是否为空队列
}
//双端队列，两端都可插入和删除
void f_deque() {
//初始化
deque<int> dq;
for (int i = 0; i < 10; i++) {
dq.push_back(i);
dq.push_front(i);
}
cout << dq.front() << " "<<dq.back() << endl;
dq.pop_front();
dq.pop_front();
cout << dq.size() << endl;
cout << dq.empty() << endl;
dq.clear();
for (auto pb = dq.begin(); pb != dq.end(); pb++) {
cout << *pb << endl;
}
}
//优先队列，使用堆实现默认将当前队列最大元素置于队首的容器（大根堆）
/*
没有front()和back()函数，只能通过top()函数访问队首元素，也就是优先级最高的元素（优先级可自定义）
*/
//结构体内部重载小于号（且只能重载小于号）实现自定义优先级
struct fruit {
string name;
int price;
friend bool operator<(fruit f1, fruit f2) {
return f1.price < f2.price;
}
};
//结构体外实现自定义优先级
struct animal {
string name;
int weight;
};
struct cmp {
bool operator()(animal a1, animal a2) {
return a1.weight > a2.weight;
}
};
void f_priority_queue() {
priority_queue<int> pq;//默认情况下为大根堆
for (int i = 0; i < 10; i++) {
pq.push(i);
}
cout << pq.top();//9，默认是大根堆
//常用操作：push(),top(),pop(),empty(),size()
//自定义优先级
priority_queue<int, vector<int>, less<int> > pq1;//用<做比较,大根堆
priority_queue<long long, vector<long long>, greater<long long> >pq2;//用>作比较，小根堆
priority_queue<double, vector<double>, less<double> > pq3;//大根堆
priority_queue<char, vector<char>, less<char> > pq4;//大根堆
priority_queue<string, vector<string>, less<string> > pq5;//大根堆
//给结构体定义优先级
//结构体内部重载小于号（且只能重载小于号）
priority_queue<fruit> q1;//如果想以价格低的水果为优先级高，那么只需要把return中的小于号改为大于号
fruit f1, f2, f3;
f1.name = "apple";
f1.price = 1;
f2.name = "banana";
f2.price = 2;
f3.name = "orange";
f3.price = 3;
q1.push(f1);
q1.push(f2);
q1.push(f3);
cout << q1.top().name << " " << q1.top().price << endl;//orange 3
//结构体外自定义cmp结构体实现自定义优先级
priority_queue<animal, vector<animal>, cmp> q2;
animal a1, a2, a3;
a1.name = "monkey";
a1.weight = 1;
a2.name = "snake";
a2.weight = 2;
a3.name = "horse";
a3.weight = 3;
q2.push(a1);
q2.push(a2);
q2.push(a3);
cout << q2.top().name << " " << q2.top().weight << endl;//monkey 1
}
//需要引入utility头文件，但由于map中已经引入了utility，所以可以省略
//pair是将两个元素绑在一起作为一个合成元素
/*
pair具有以下两个用途：
1.用以代替二元结构体及其构造函数，可以节省编码时间
2.作为map的键值对来进行插入
*/
void f_pair() {
//初始化
{
pair<string, int> p1;
pair<string, int> p2("this is a key of a pair", 1);
pair<string, int>("this is an anonymous pair", 2);//有点类似于匿名内部类
auto p3 = pair<string, int>("this is an anonymous pair", 2);
auto p4 = make_pair<string, int>("make_pair", 3);
pair<string, int> p5;
p5.first = "hello world!";
p5.second = 4;
cout << p5.first << " " << p5.second << endl;
}
//pair的比较
/*
先以first的大小作为标准，仅当first相等时才去判断second的大小
*/
pair<int, int> p6(5, 10);
pair<int, int> p7(5, 15);
pair<int, int> p8(10, 5);
if (p6 < p8) cout << "p1<p8" << endl;//true
if (p6 <= p8) cout << "p1<=p8" << endl;//true
if (p6 < p7)cout << "p1<p7" << endl;//true
//作为map的键值对元素
map<string, int> mp;
mp.insert(make_pair("make_pair",1));
mp.insert(pair<string, int>("pair key", 2));
pair<string, int> pair_tmp("another pair", 3);
mp.insert(pair_tmp);
}
void f_string() {
char c_type_str[] = "this is a c type string,using a char array";
cout << "c style string: " << c_type_str << endl;
cin.getline(c_type_str, sizeof(c_type_str) / sizeof(c_type_str[0]));
//convert a c style string to string
string cpp_type_str(c_type_str);
string cpp_type_str2 = c_type_str;
cout << "string cpp_type_str: " << cpp_type_str << endl;
//convert a string to c style string
const char* c_type_str2 = cpp_type_str.c_str();
c_type_str2 = "another c style string";
//读取行
string str_getline;
getline(cin, str_getline);//从标准输入中读取整行并赋值给str
//访问string中的单个元素
string str = "this is a demo string";
cout << str[2]; //用下标访问str中的元素
cout << (*(str.begin()))<<" "<< (*(str.begin()+4)) << endl; //使用迭代器访问str中的元素
cout<<str.length();
cout << str.size();
str.insert(3,"tmp_str");//insert(pos,string)，在str[3]处插入tmp_str
string str_tmp = "this is a tmp string for insert";
//str.insert(it,it2,it3);it为原字符串欲插入位置，it2，it3待插入字符串的首尾迭代器
//在str的指定迭代器位置，插入str_tmp迭代器指定的一段字符串
str.insert(str.begin(),str_tmp.begin(),str_tmp.begin()+4);
str.erase(str.begin() + 2);
str.erase(str.begin(), str.end() - 1);
str.erase(3,2);//从3号位置删除2个字符
str.clear();
str.empty();
str.substr(0,5);//substr(pos,len);截取0号开始的5个字符子串
cout << string::npos << endl;
str = "thank you very much!";
str_tmp = "thank";
cout << ((str.find(str_tmp)) == (string::npos)) << endl;
//str.replace(pos,len,str2);把pos开始的长度为len的子串替换为str2
str.replace(10,4,str_tmp);
//str.replace(it1,it2,str2);把it1和it2之间的子串替换为str2
str.replace(str.begin(),str.begin()+3,str_tmp);
}
//基本数据类型使用自定义cmp函数实现排序
bool cmp1(int a, int b) {
return a > b;//降序排序
}
struct book {
int num;
double price;
};
//自定义compare函数实现一级排序，按照book的价格降序排序
bool cmp2(book b1, book b2) {
return b1.price > b2.price;
}
//自定义compare函数实现二级排序，按照book的价格降序排序，编号升序
bool cmp3(book b1, book b2) {
return b1.price == b2.price ? b1.num<b2.num : b1.price>b2.price;
}
//自定义compare函数实现字符串字典序降序排序
bool cmp4(string str1, string str2) {
return str1 > str2;
}
//自定义compare函数实现按字符串长度降序
bool cmp5(string str1, string str2) {
return str1.length() > str2.length();
}
void f_algorithm() {
//0. max(),min(),abs(),swap()
int a = 1, b = -2;
cout << max(a, b) << " " << min(a, b) << endl;
cout << abs(b) << endl;
swap(a, b);
//1.排序，sort，默认升序
int ia[] = { 4,5,62,1,5,79,2 };
for (int i = 0; i < 7; i++) {
cout << ia[i];
}
sort(ia, ia + 7);
for (int i = 0; i < 7; i++) {
cout << ia[i];
}
//自定义compare函数
//1.基本数据类型使用自定义compare函数
sort(ia, ia + 7, cmp1);//自定义cmp1中使用>号实现降序排序（默认情况下升序排序）
for (int i = 0; i < 7; i++) {
cout << ia[i];
}
//2.1自定义结构体使用自定义compare函数实现一级排序
book arr_book[10];
for (int i = 0; i < 10; i++) {
arr_book[i].num = i * i;
arr_book[i].price = i / (arr_book[i].num);
}
sort(arr_book, arr_book + 10, cmp2);
//2.2自定义结构体使用自定义compare函数实现二级排序
sort(arr_book, arr_book + 10, cmp2);
//3.容器的排序
//vector举例，实际上与数组相差不大，注意cmp函数的自定义即可
vector<int> vi;
for (int i = 0; i < 10; i++) {
vi.push_back(i);
}
sort(vi.begin(), vi.end(), cmp1);//cmp1中使用>号，实现降序排序
//string举例
// 1.compare实现字典序降序
string arr_str[] = { "aaab","aab","ab" };
sort(arr_str, arr_str + 3, cmp4);
// 2.compare实现按字符串长度降序
sort(arr_str, arr_str + 3, cmp5);
//4.使用functional中提供的模板函数（需加入functional头文件）
sort(ia, ia + 7, less<int>());
sort(ia, ia + 7, greater<int>());
//2.翻转，reverse(it1,it2)，翻转[it1,it2)之间的元素
vector<int> v1 = { 0,1,2,3,4,5,6,7,8,9 };
for (auto it = v1.begin(); it != v1.end(); it++) {
cout << *it << " ";
}
reverse(v1.begin(), v1.end());
for (auto it = v1.begin(); it != v1.end(); it++) {
cout << *it << " ";
}
string str = "you know how much I like you";
reverse(str.begin(), str.end());
cout << str << endl;
//3.next_permutation()，给出一个序列在全排列中的下一个序列
//next_permutation(it1,it2)在到达全排列的最后一个时会返回false，使用do-while输出最开始的排列123
int arr[] = { 1,2,3 };
do {
for (int i = 0; i < 3; i++) {
cout << arr[i];
}
} while (next_permutation(arr, arr + 3));
//4.fill(it1,it2,value)赋予[it1,it2)迭代器指定区间元素值value
int arr2[] = { 1,2,3,4,5 };
fill(arr2, arr2 + 5, 6666);
//5.lower_bound()和upper_bound()，用于有序数组和容器中
/*
lower_bound(first,last,val),Returns an iterator pointing to the first element
in the range [first, last) that is not less than (i.e. greater or equal to)
value, or last if no such element is found.
upper_bound(first,last,val),Returns an iterator pointing to the first element
in the range [first, last) that is greater than value, or last if no such
element is found.
*/
int arr_i[10] = { 1,2,2,3,4,4,5,5,5,5 };
int* lowerpos = lower_bound(arr_i, arr_i + 10, 2);
int* upperpos = upper_bound(arr_i, arr_i + 10, 5);
}
void f_cctype() {
//常用函数,
string str = "this is a random string with alphabetic character a-zA-Z and decimal digits:0123456789";
cout<<isalpha(str[10])<<endl; //是否为字母
cout << isdigit(str[100]) << endl; //是否为数字
cout << isalnum(str[0]) << endl; //是否为字母或者数字
}
//常用的数学函数
void f_math() {
cout <<"abs(-1) " << abs(-1) << endl;
cout <<"floor(2.1) " << floor(2.1) << endl;
cout <<"ceil(2.1) "<< ceil(2.1) << endl;
cout << "pow(2.0,3.0) " << pow(2.0, 3.0) << endl;
cout << "sqrt(4.0)" << sqrt(4.0) << endl;
cout << "log(1) " << log(1) << endl;
cout << "round(4.4) " << round(4.4) << " round(4.5) " << round(4.5) << endl;
cout << "(int)(4.4 + 0.5) "<< (int)(4.4 + 0.5) <<" (int)(4.5 + 0.5) " << (int)(4.5 + 0.5) << endl;
}
//冒泡排序
void f_bubble_sort() {
const int sz = 10;
int a[sz] = { 9,3,1,5,2,4,8,7,10,6 };
for (int i = 0; i < sz-1; i++) {
for (int j = 0; j < sz - i - 1; j++) {
if (a[j] < a[j + 1]) {
swap(a[j],a[j+1]);
}
}
}
for (int tmp : a) {
cout << tmp << " ";
}
cout << endl;
}
//是否为闰年
bool isleapyear(int year) {
return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}
//最大公约数(greatest common divisor)
//辗转相除法，也叫欧几里得算法
long long gcd(long long a,long long b) {
return b == 0 ? a : gcd(b, a % b);
}
//最小公倍数（lowest common multiple）
//最小公倍数 = a*b/最大公约数
long long lcm(long long a,long long b) {
return a * b / (gcd(a,b));
}
//进制转换
//其它进制转换为十进制,str为base进制下的字符串表示
/*
long strtol( const char *str, char **str_end, int base);需要使用'#include<cstdlib>'
丢弃所有空白字符（通过调用isspace（）进行标识），直到找到第一个非空白字符为止，然后使用尽
可能多的字符来形成有效的以n为基（其中n = base）的整数表示并将其转换为一个整数值（十进制）。
*/
long xtod(string str,int base) {
char* tmp;
return strtol(str.c_str(), &tmp, 8);
}
//十进制转换为其它进制，digital为10进制数，r为需要转换的目标进制，返回目标进制数
string dtox(int digital, int r) {
string result = "";
const char s[37] = "0123456789abcdefghijklmnopqrstuvwxyz";
if (digital == 0) {
return "0";
}
while (digital != 0) {
int tmp = digital % r;
result += s[tmp];
digital /= r;
}
reverse(result.begin(), result.end());
return result;
}
//string和其他基本数据类型的相互转换
void f_convert() {
//string to int/long/long long/double
string str = "123456789";
int i = stoi(str);
long l = stol(str);
long long ll = stoll(str);
double db = stod(str);
//int/long/long long/double to string
string str_i = to_string(i);
string str_long = to_string(l);
string str_long_long = to_string(ll);
string str_db = to_string(db);
}
int main9() {
//f_bit_operation();
//f_math();
//f_bubble_sort();
//f_string();
return 0;
}