c++语法基础
#include <iostream>
using namespace std;
int main(){
cout << "Hello World" << endl;
return 0;
}
入门及简单的顺序结构
1、变量的定义
变量类型：
| 类型 | 关键字 | 大小 |
|---|---|---|
| 布尔型 | bool | 1btye |
| 字符型 | char | 1btye |
| 整型 | int | 4btye |
| 浮点型（单精度） | float | 4btye |
| 双浮点型（双精度） | double | 8btye |
变量必须先定义，才可以使用。不能重名。
int main() {
int a, b = 2, c = b;
float d = 1.5, f = 1.23e2;
bool g = true;
char j = 'a';
return 0;
}
2、输入输出
int main() {
int a, b;
cin >> a >> b;//输入
cout << a + b <<' '<< a * b << endl;//输出，endl是回车
//先输出a+b，再输出空格，再输出a*b，最后回车
return 0;
}
int main() {
int a, b;
scanf("%d%d", &a, &b);
printf("%d %d", a + b, a * b);
printf("a+b=%d\na*b=%d", a + b, a * b);
float c;
scanf("%f",&c);
printf("a+c=%.2f",a+c);
return 0;
}
/*
* int:%d
* float:%f
* double:%lf
* char:%c
* long long:%lld
* bool:用0和1表示
*/
scanf会把空格读入，cin不会读入空格。
printf拓展：
-
Float, double 等输出保留若干位小数时用：%.4f, %3lf
-
%8.3f, 表示这个浮点数的最小宽度为 8，保留 3 位小数，当宽度不足时 在前面补空格。
-
%-8.3f，表示最小宽度为 8，保留 3 位小数，当宽度不足时在后面补上空 格
-
%08.3f, 表示最小宽度为 8，保留 3 位小数，当宽度不足时在前面补上 0
3、表达式
int main() {
int a = 6 + 3 * 4 / 2 - 2;
cout << a << endl;
int b = a * 10 + 5 / 2;
cout << b << endl;
cout << 23 * 56 - 78 / 3 << endl;
cout << 5 % 2 << endl;//1 正数取模为正
cout << -5 % 2 << endl;//-1 负数取模为负
return 0;
}
4、变量类型转化
int main() {
float x = 123.12;
int y = (int) x;
cout << x << ' ' << y << endl;//向下取整
return 0;
}
隐式转换：低精度转为高精度
5、常量的定义
#include <iostream>
#include <cstdio>
using namespace std;
const double eps=1e-6; //定义常量
int main() {
……
return 0;
}
浮点数的比较
int main() {
if (sqrt(3) * sqrt(3) - 3 <= eps) {
printf("equal");
} else {
printf("no");
}
return 0;
}
判断结构
1.基本 if-else 语句：
当条件成立时，执行某些语句；否则执行另一些语句。else语句可以省略
int main() {
int score;
cin >> score;
if (score >= 60) {
cout << "及格" << endl;
} else {
cout << "不及格" << endl;
}
return 0;
}
2.if-else if-else语句：
int main() {
int score;
cin >> score;
if (score >= 85) cout << 'A' << endl;
else if (score>=60) cout << 'B' << endl;
else cout<<'C'<<endl;
return 0;
}
3.条件表达式
与 && 或 || 非 ！
循环
1.while循环
int main() {
int i=1,sum=0;
while(i<=100){
sum+=i;
i++;
}
printf("%d",sum);
return 0;
}
求斐波那契数列的第 n 项。f(1)=1, f(2)=1, f(3)=2, f(n)=f(n-1) + f(n-2)。
int main() {
int n;
cin>>n;
int a=1,b=1,i=1;
while(i<n){
int c=a+b;
a=b;
b=c;
i++;
}
cout<<a<<endl;
return 0;
}
2.do while
int main() {
int n=10,i=1,sum=0;
do{
sum+=i;
i++;
}while(i<=10);
printf("%d",sum);
return 0;
}
3.for循环
for（初始化语句；条件语句；表达式）语句；
int main() {
int i,sum;
for(i=1,sum=0;i<=100;i++){
sum+=i;
}
printf("%d",sum);
return 0;
}
4.continue语句
int main() {
int i,sum;
for(i=1,sum=0;i<=100;i++){
if(i%2==0){
continue;
}
sum+=i;
}
printf("%d",sum);
return 0;
}
5.break语句
int main() {
int i,sum;
for(i=1,sum=0;i<=100;i++){
if(sum>2000){
break;
}
sum+=i;
}
printf("%d",sum);
return 0;
}
数组
1.一维数组
1.1数组初始化
int main() {
int a[10],b[20];
float f[33];
double d[123];
char c[21];
return 0;
}
1.2数组初始化
int main() {
int a[3]={0,1,2};
int b[]={0,1,2};
int c[5]={0,1,2}; //等价于c[]={0,1,2,0,0},默认值为0
char d[3]={'a','b','c'}; //字符数组初始化
int f[10]={0}; //将数组全部初始化为0的写法
return 0;
}
函数内部定义数组有长度限制，如果数组太长运行报错（超出栈长），可以将数组定义在函数外（堆）。
函数内部定义的变量（局部变量）为随机值，函数外面定义的变量（全局变量）都是0。
1.3数组下标引用
int main() {
int a[3] = {0, 1, 2};
cout << a[0] << ' ' << a[1] << ' ' << a[2] << endl;
a[0] = 5;
cout << a[0] << endl;
return 0;
}
1.4翻转数组
//头文件 #include <algorithm> //使用方法 reverse(a, a+n);//n为数组中的元素个数 reverse(a,a+n);//翻转整个数组 reverse(a,a+k);//翻转前k个元素 reverse(a+k,a+n);//反转后n-k个元素
1.5高精度计算
#include <iostream>
#include <cstdio>
using namespace std;
int main() {
int a[10000] = {1};
int n, size = 1;
cin >> n;
while (n--) {
int t =0;
for (int i = 0; i < size; i++) {
t+=a[i]*2;
a[i]=t%10;
t/=10;
}
if(t) a[size++]=1;
}
for (int i = size - 1; i >= 0; i--) {
cout << a[i];
}
return 0;
}
2.多维数组
1.1数组定义
int main() {
int a[3][4];
int arr[10][20][30]={0};
int b[3][4]={
{0,1,2,3},
{4,5,6,7},
{8,9,10,11}
};
for(int i=0;i<3;i++){
for(int j=0;j<4;j++){
cout<<b[i][j]<<' ';
}
}
return 0;
}
1.2初始化数组
#include <iostream>
#include <cstring>//头文件
using namespace std;
int main() {
int a[10];
memset(a,0,40);//数组的名字，初始化内容（把每一个字节赋值为0或其他），初始化的长度（以字节为单 位，一个int占4个byte）
memset(a,-1,sizeof a);
for (int i = 0;i<10;i++){
cout<<a[i]<<' ';
}
return 0;
}
1.3复制数组
#include <iostream>
#include <cstring>
using namespace std;
int main() {
int a[10],b[10];
for (int i=0;i<10;i++){
a[i]=i;
}
memcpy(b,a,sizeof a);//目标数组，原数组，长度
return 0;
}
字符串
1.字符与整数的联系——ASCII 码
每个常用字符都对应一个-128~127 的数字，二者之间可以相互转化：
int main() {
char c = 'a';
cout << (int) c << endl;
cout << (char) 97 << endl;
return 0;
}
常用 ASCII 值：’A’-‘Z’ 是 65~90，’a’-‘z’是 97-122，’0’-‘9’是 48-57。 字符可以参与运算，运算时会将其当做整数：
int main() {
int a='B'-'A';
int b='A'*'B';
char c='A'-2;
cout<<a<<endl;
cout<<b<<endl;
cout<<c<<endl;
return 0;
}
2.字符数组
字符串就是字符数组加上结束符’\0’。 可以使用字符串来初始化字符数组，但此时要注意，每个字符串结尾会暗含一个’\0’字符，因此字符数组的长度至少要比字符串的长度多 1！
int main() {
char a1[]={'C','+','+'};
char a2[]={'C','+','+','\0'};
char a3[]="C++"; //a[2],a[3]等价
char a4[6]="abcdef"; //错误：没有空间存放空字符
return 0;
}
2.1字符数组输入输出
int main() {
char str[100];
cin>>str; //输入时，遇到空格或回车就会停止
char str[100];
scanf("%s",str); //注：不加&
cout<<str<<endl;
printf("%s\n",str); //输出时，遇到空格或回车不会停止
puts(str);
return 0;
}
读入一行字符串，包括空格：
int main() {
char str[100];
fgets(str,100,stdin); //最大长度为100 //会读入回车（不建议使用）
cin.getline(str,100);
cout << str << endl;
string s;
getline(cin,s); //必须是string类型
cout<<s<<endl;
return 0;
}
从某个位置开始输出：
int main() {
char str[] = "abcdefgh";
cout << str << endl; //从a开始输出
cout << str + 1 << endl; //从b开始输出（从下标1开始输出）
return 0;
}
数组从下标[1]开始：
int main() {
char str[100];
scanf("%s",str+1);
cin>>str+1;
cout<<str<<endl;
return 0;
}
2.2 字符数组的常用操作
下面几个函数需要引入头文件:
#include <string.h><cstring> (1) strlen(str)，求字符串的长度
(2) strcmp(a, b)，比较两个字符串的大小，a < b 返回-1，a == b 返回 0，a > b 返回 1。这里的比较方式是字典序！
(3) strcpy(a, b)，将字符串 b 复制给从 a 开始的字符数组。
3.3遍历字符数组中的字符：
int main() {
char a[100]="hello world";
for(int i=0;i<strlen(a);i++){ //双层循环，每次strlen都要遍历一次
cout<<a[i]<<endl;
}
for(int i=0,len=strlen(a);i<len;i++){ //优化
cout<<a[i]<<endl;
}
return 0;
}
3.标准库类型string
可变长的字符序列，比字符数组更加好用。需要引入头文件： #include <string>
3.1 定义和初始化
int main() {
string s1; //默认初始化，s1是一个空字符串
string s2=s1; //s2是s1的副本
string s3="hello"; //s3是该字符串字面值的副本
string s4(10,'c'); //s4的内容是cccccccccc
return 0;
}
3.2 string 上的操作
（1）输入输出操作
int main() {
string s1, s2;
cin >> s1 >> s2;
cout << s1 << ' ' << s2 << endl;
printf("%s\n",s1.c_str());
return 0;
}
注意：不能用scanf输入；不能用 printf 直接输出 string，需要写成：printf(“%s”, s.c_str(））
（2）使用 getline 读取一整行：
int main() {
string s1, s2;
getline(cin, s1);
cout << s1 << endl;
return 0;
}
（3）string 的 empty 和 size 操作（注意 size 是无符号整数，因此 s.size()<= -1 一定成立）：
int main() {
string s1, s2 = "abc";
cout << s1.empty() << endl;
cout << s2.empty() << endl;
cout << s2.size() << endl;
return 0;
}
（4）string 的比较： 支持 > < >= <= == !=等所有比较操作，按字典序进行比较。
（5）两个 string 对象相加：
int main() {
string s1="hello ",s2="world\n";
string s3 = s1 + s2;
string s4 = s1 + "," + s2 + '\n';
cout<<s3<<endl;
return 0;
}
当把 string 对象和字符字面值及字符串字面值混在一条语句中使用时，必须确保每个加法运算符的两侧的运算对象至少有一个是 string： string s4 = s1 + “, “; // 正确：把一个 string 对象和有一个字面值相加 string s5 = “hello” +”, “; // 错误：两个运算对象都不是 string string s6 = s1 + “, “ + “world”; // 正确，每个加法运算都有一个运算符是 string string s7 = “hello” + “, “ + s2; // 错误：不能把字面值直接相加，运算是从左到右进行的
3.3 处理 string 对象中的字符
可以将 string 对象当成字符数组来处理：
int main() {
string s="hello world";
for(int i=0;i<s.size();i++){
cout<<s[i]<<endl;
}
return 0;
}
int main() {
string s = "hello world";
for (char c:s) cout << c << endl;
for (char &c:s) c = 'a'; //改变原内容需要加&
for (auto c:s) cout << c << endl; //auto:编译器自己猜类型
return 0;
}
3.4取字符串的某一段
int main() {
string s1;
getline(cin,s1);
cout<<s1.substr(0,5); //参数：(起止位置，长度)（长度省略一直到结尾）
return 0;
}
3.5字符串流
导入库函数 #include <sstream>
把一个字符串初始化成类似cin的东西，得到我们任意想要的格式
int main() {
string s;
getline(cin, s);
stringstream ssin(s);
int a, b;
string str;
double c;
ssin >> a >> str >> b >> c;
cout << a << endl << str << endl << b << endl << c << endl;
return 0;
}
3.5字符串最后一位处理
int main() {
string s;
cin>>s;
cout<<s.back()<<endl; //s.back()返回最后一位字符
s.pop_back(); // s.pop_back()删去最后一位字符
return 0;
}
函数
1. 函数基础
一个典型的函数定义包括以下部分：返回类型、函数名字、由 0 个或多个形参组成的列表以及函数体。
1.1 编写函数
//函数声明
int func(int n);
//函数定义
int func(int n) {
int res = 1;
for (int i = 1; i <= n; i++) {
res *= i;
}
return res;
}
//调用函数
int main() {
int t = func(5);
cout << t << endl;
return 0;
}
1.2形参和实参
实参是形参的初始值。第一个实参初始化第一个形参，第二个实参初始化第二个形参，依次类推。形参和实参的类型和个数必须匹配。 fact(“hello”); // 错误：实参类型不正确 fact(); // 错误：实参数量不足 fact(42, 10, 0); // 错误：实参数量过多 fact(3.14); // 正确：该实参能转换成 int 类型，等价于 fact(3); 形参也可以设置默认值，但所有默认值必须是最后几个。当传入的实参个数少于形参个数时，最后没有被传入值的形参会使用默认值。
1.3函数的形参列表
函数的形参列表可以为空，但是不能省略。 void f1() {/ .... /} // 隐式地定义空形参列表 void f2(void) {/ ... /} // 显式地定义空形参列表 形参列表中的形参通常用逗号隔开，其中每个形参都是含有一个声明符的声 明。即使两个形参的类型一样，也必须把两个类型都写出来： int f3(int v1, v2) {/ ... /} // 错误 int f4(int v1, int v2) {/ ... /} // 正确
1.4局部变量、全局变量与静态变量
局部变量只可以在函数内部使用，全局变量可以在所有函数内使用。当局部 变量与全局变量重名时，会优先使用局部变量。
静态变量：（等价于在函数内部开了一个只有该函数能用的全局变量）
int output(){
static int cnt=0; //静态变量：无论调用函数多少次，都使用同一个变量，初始化只在第一次调用执行
cnt++;
cout<<cnt<<"times"<<endl;
}
int main() {
output();
output();
output();
output();
return 0;
}
2.参数传递
2.1 传值参数
当初始化一个非引用类型的变量时，初始值被拷贝给变量。此时，对变量的改动不会影响初始值。
int func(int x){
x=5;
return x;
}
int main() {
int x=10;
int t=func(x);
cout<<x<<' '<<t<<endl; //10 5
return 0;
}
2.2 传引用参数
当函数的形参为引用类型时，对形参的修改会影响实参的值。使用引用的作用：避免拷贝、让函数返回额外信息。
int func(int &x){
x=5;
return x;
}
int main() {
int x=10;
int t=func(x);
cout<<x<<' '<<t<<endl; //5 5
return 0;
}
2.3 数组形参
在函数中对数组中的值的修改，会影响函数外面的数组。
一维数组形参的写法： // 尽管形式不同，但这三个 print 函数是等价的 void print(int *a) {/ ... /} void print(int a[]) {/ ... /} void print(int a[10]) {/ ... /}
void output(int n,int a[3]){ //output(int n,int *a) output(int n,int a[])
for(int i=0;i<n;i++){
cout<<a[i]<<endl;
}
}
int main() {
int a[3]={1,2,3};
output(3,a);
return 0;
}
多维数组形参的写法： // 多维数组中，除了第一维之外，其余维度的大小必须指定 void print(int (*a)[10]) {/ ... /} void print(int a[][10]) {/ ... /}
void output(int n, int m, int a[][3]) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << a[i][j] << endl;
}
}
}
int main() {
int a[3][3] = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9},
};
output(3, 3, a);
return 0;
}
3.返回类型和 return 语句
return 语句终止当前正在执行的函数并将控制权返回到调用该函数的地方 。 return 语句有两种形式： return; return expression;
3.1有返回值的函数
只要函数的返回类型不是 void，则该函数内的每条 return 语句必须返回一个值。return 语句返回值的类型必须与函数的返回类型相同，或者能隐式地转换函数的返回类型。
3.2无返回值函数
没有返回值的 return 语句只能用在返回类型是 void 的函数中。返回 void 的函数不要求非得有 return 语句，因为在这类函数的最后一句后面会隐式地执行return。 通常情况下，void 函数如果想在它的中间位置提前退出，可以使用 return 语句。return 的这种用法有点类似于我们用 break 语句退出循环。
void swap(int &v1, int &v2)
{
// 如果两个值相等，则不需要交换，直接退出
if (v1 == v2)
return;
// 如果程序执行到了这里，说明还需要继续完成某些功能
int tmp = v2;
v2 = v1;
v1 = tmp;
// 此处无须显示的 return 语句
}
4.函数递归
在一个函数内部，调用函数本身。
using namespace std;
int fact(int n){
if(n<=1) return 1;
return n*fact(n-1);
}
int main() {
int n;
cin>>n;
cout<<fact(n)<<endl;
return 0;
}
类、结构体、指针、引用
1.类与结构体
1.类
类中的变量和函数被统一称为类的成员变量。
private 后面的内容是私有成员变量，在类的外部不能访问；public 后面的内容是公有成员变量，在类的外部可以访问。
class Person{
private:
int age,height;
double money;
string books[100];
public:
string name;
void say(){
cout<<"i am "<<name<<endl;
}
int get_age(){
return age;
}
void add_money(double x){
money+=x;
}
}; //类后面要加分号
int main() {
Person c;
c.name="hutao";
//c.age=18; //错误！age是私有变量
c.add_money(1000);
cout<<c.get_age()<<endl;
return 0;
}
2.结构体
结构体和类的作用是一样的。不同点在于类默认是 private，结构体默认是 public。
struct Person{
private:
int age,height;
double money;
string books[100];
public:
string name;
void say(){
cout<<"i am "<<name<<endl;
}
int set_age(int a){
age=a;
}
int get_age(){
return age;
}
void add_money(double x){
money+=x;
}
} person_a,person_b,persons[100]; //定义完直接声明
(习惯上把只有数据的、函数比较少的定义为结构体；函数麻烦的、多的打包为类)
3.构造函数
struct Person{
int age,height;
double money;
Person(){} //没有参数的构造函数
Person(int _age,int _height,double _money){ //构造函数
age =_age;
height=_height;
money=_money;
}
//构造函数也可以写成
Person(int _age,int _height,double _money) : age(_age),height(_height),money(_money){}
};
int main() {
Person p1(18,185,100.0);
Person p2={20,186,200.5};
cout<<p1.age<<' '<<p2.money<<endl;
return 0;
}
2.指针与引用
指针指向存放变量的值的地址。因此我们可以通过指针来修改变量的值。
int main() {
int a = 10;
int *p = &a; //这里的*代表变量p是指针类型，可以看作int* p（定义int类型的指针,p为变量名称）
*p += 5;
cout << *p << endl; //求变量p的值，此处*为操作符
return 0;
}
数组名是一种特殊的指针。指针可以做运算：
int main() {
int a[5] = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; i++) {
cout << *(a + i) << endl; //指针+1的长度加的是一个类型的长度
}
return 0;
}
int main() {
int a[5] = {1, 2, 3, 4, 5};
int *p = &a[0], *q = &a[2];
cout << q - p << endl; //2
return 0;
}
引用和指针类似，相当于给变量起了个别名。
int main() {
int a=10;
int &p=a; //定义一个变量p，与a同一个地址。
p+=5;
cout<<p<<' '<<a<<endl;
return 0;
}
3.链表
struct Node {
int val;
Node *next;
Node(int _val) : val(_val), next(NULL) {}
};
int main() {
Node node = Node(1);
Node *p = &node; //一般习惯定义完放指针里
//以上两步等价于一步
Node *p=new Node(1);//没有new代表定义一个Node变量值是1；有new代表定义了一个Node变量返回值是地址
Node *q = new Node(2);
Node *o = new Node(3);
p->next = q;//调用类里面成员变量时，如果变量是指针(地址)用’->‘;不是指针用变量名＋‘.’
q->next = o;
Node *head = p;//说链表的头结点大部分情况下说的是第一个节点的地址，而不是值。
for(Node* i=head;i;i=i->next){ //链表的遍历
cout<<i->val<<endl;
}
return 0;
}
STL
1.vector
#include <vector>
vector 是变长数组，支持随机访问，不支持在任意位置 O(1)插入。为了保证效率，元素的增删一般应该在末尾进行。
int main() {
vector<int> a; //相当于一个长度动态变化的 int 数组
vector<int> a({1,2,3});
vector<int> b[233]; //相当于第一维长 233，第二维长度动态变化的 int 数组
struct rec{
int x,y;
};
vector<rec> c; //自定义的结构体类型也可以保存在 vector 中
a.size(); //返回 vector 的实际长度（包含的元素个数）
a.empty(); //返回一个bool 类型，表明 vector 是否为空。
a.clear(); //把 vector 清空。
return 0;
}
迭代器： 迭代器就像 STL 容器的“指针”，可以用星号“*”操作符解除引用。 一个保存 int 的 vector 的迭代器声明方法为：
vector<int>::iterator it = a.begin();
vector 的迭代器是“随机访问迭代器”，可以把 vector 的迭代器与一个整数相加减，其行为和指针的移动类似。可以把 vector 的两个迭代器相减，其结果也和指针相减类似，得到两个迭代器对应下标之间的距离。
begin/end: begin 函 数 返 回 指 向 vector 中 第 一 个 元 素 的 迭 代 器 。 例 如 a 是 一 个 非 空 的vector，则*a.begin()与 a[0]的作用相同。 所有的容器都可以视作一个“前闭后开”的结构，end 函数返回 vector 的尾部，即 第 n 个 元 素 再 往 后 的 “ 边 界 ” *a.end() 与 a[n] 都 是 越 界 访 问 ， 其 中n=a.size()。
//下面代码都遍历了 vector<int>a，并输出它的所有元素。 for (int i = 0; i < a.size(); i ++) cout << a[i] << endl; for (vector<int>::iterator it = a.begin(); it != a.end(); it ++) cout <<*it << endl; for (auto it = a.begin(); it != a.end(); it ++) cout <<*it << endl;//用auto替代 for(int x:a) cout<<x<<' ';//范围遍历，与string一样
front/back front 函数返回 vector 的第一个元素，等价于*a.begin() 和 a[0]。 back 函数返回 vector 的最后一个元素，等价于a[a.size() –1]。
cout<<a.front()<<' '<<a[0]<<endl; cout<<a.back()<<' '<<a[a.size()-1]<<endl;
push_back() 和 pop_back() a.push_back(x) 把元素 x 插入到 vector a 的尾部。 a.pop_back() 删除 vector a 的最后一个元素。
2.queue
#include <queue>
头文件 queue 主要包括循环队列 queue 和优先队列 priority_queue 两个容器。
queue<int> q;
struct rec{
int a,x,y;
};
queue<rec> q;//结构体rec的队列
priority_queue<int> q; // 大根堆
priority_queue<int, vector<int>, greater<int> q; // 小根堆
priority_queue<pair<int, int>>q; //pair二元组
struct rec {
int a, b;
bool operator<(const rec &t) const {
return a < t.a;
}
};
priority_queue<rec> q;//定义结构体类型的大根堆，结构体 rec 中必须定义小于号；小根堆定义大于号.
循环队列 queue： queue<int> q;//队头插入，队尾弹出 q.push(1);//在对头插入一个元素 q.pop();//弹出队尾元素 q.front();//返回队头 q.back();//返回队尾 优先队列 priority_queue： priority_queue<int> a; a.push(1);//插入一个数 a.top();//取最大值 a.pop();//删除最大值
队列没有clear，如果要清空队列，重新初始化即可
q = queue<int>();
3.stack
#include <stack>
stack<int> stk; stk.push(1); //向栈顶插入 stk.top(); //返回栈顶元素 stk.pop(); //弹出栈顶元素
4.deque
#include <deque>
双端队列 deque 是一个支持在两端高效插入或删除元素的连续线性存储空间。它就像是 vector 和 queue 的结合。与 vector 相比，deque 在头部增删元素仅需要 O(1)的时间；与 queue 相比，deque 像数组一样支持随机访问。
deque<int> a; a.begin(),a.end(); //返回 deque 的头/尾迭代器 a.front(),a.back(); //队头/队尾元素 a.push_back(1); //从队尾入队 a.push_front(1); //从队头入队 a.pop_back(); //从队尾出队 a.pop_front(); //从队头出队 a.clear(); //清空队列
5.set
#include <set>
头文件 set 主要包括 set 和 multiset 两个容器，分别是“有序集合”和“有序多重集合”，即前者的元素不能重复，而后者可以包含若干个相等的元素。set 和 multiset 的内部实现是一棵红黑树，它们支持的函数基本相同。
set<int> a; //元素不能重复
multiset<int> b; //元素可以重复
struct rec {
int x, y;
bool operator<(const rec &t) const {
return x < t.x;
}
};
set<rec> c;
a.size(); a.empty(); a.clear();
迭代器: set 和 multiset 的迭代器称为“双向访问迭代器”，不支持“随机访问”，支持星号(*)解除引用，仅支持”++”和--“两个与算术相关的操作。 设 it 是一个迭代器，例如 :
set<int>::iterator it = a.begin();
若把 it++，则 it 会指向“下一个”元素。这里的“下一个”元素是指在元素从小到大排序的结果中，排在 it 下一名的元素。同理，若把 it--，则 it 将会指向排在“上一个”的元素。
s.begin();//是指向集合中最小元素的迭代器。 s.end();//是指向集合中最大元素的下一个位置的迭代器。因此--s.end()是指向集合中最大元素的迭代器。
insert/find:
s.insert(x); //把一个元素 x 插入到集合 s 中，时间复杂度为 O(logn)。 s.find(x); //在集合 s 中查找等于 x 的元素，并返回指向该元素的迭代器。若不存在，则返回 s.end()。时间 复杂度为 O(logn)。 if(s.find(x)==s.end())//来判断x是否存在
lower_bound/upper_bound:
这 两 个 函 数 的 用 法 与 find 类 似 ， 但 查 找 的 条 件 略 有 不 同 ， 时 间 复 杂 度 为O(logn)。
s.lower_bound(x);//查找大于等于 x 的元素中最小的一个，并返回指向该元素的迭代器。 s.upper_bound(x);//查找大于 x 的元素中最小的一个，并返回指向该元素的迭代器。
erase：
s.erase(it);//从 s 中删除迭代器 it 指向的元素，时间复杂度为O(logn) s.erase(x);//从 s 中删除所有等于 x 的元素，时间复杂度为O(k+logn)，其中 k 是被删除的元素个数。
count:
s.count(x);//返回集合 s 中等于 x 的元素个数，时间复杂度为 O(k +logn)，其中k 为元素 x 的个数。
6.map
#include <map>
map 容器是一个键值对 key-value 的映射，其内部实现是一棵以 key 为关键码的红黑树。Map 的 key 和 value 可以是任意类型，其中 key 必须定义小于号运算符。
map<string,int> a; a["hello"]=2; cout<<a["hello"]<<endl;
map<string,vector<int>> a;
a["hello"]=vector<int>({1,2,3,4});
cout<<a["hello"][2]<<endl;
size/empty/clear/begin/end 均与 set 类似。
insert/erase:
map<string,int> a;
a.insert({"hi",3}); //插入一个二元组
cout<<a["hi"]<<endl;
cout << (a.find("hi") == a.end()) << endl;//a.find(x) 在变量名为 a 的 map 中查找 key 为 x 的二元组。
7.bitset
#include <bitset>
bitset<1000> a; //定义一个长度为1000的0、1串，默认为0 a[0]=1; cout<<a.count();//返回1的个数 a.set(3);//把第三位设成1 a.reset(3);//把第三位设成0
位运算
& 与 0&0=0; 0&1=0; 1&0=0; 1&1=1; | 或 0|0=0; 0|1=1; 1|0=1; 1|1=1; ~ 非 ~0=1; ~1=0; ^ 异或 0^0=0; 1^1=0; 1^0=1; 0^1=1; >> 右移 a>>k(a右移k位) 等价于 a除以2的k次方 << 左移 a<<k(a左移k位) 等价于 a乘以2的k次方
常用操作： (1) 求 x 的第 k 位数字 x >> k & 1 (2) lowbit(x) = x & -x，返回 x 的最后一位 1 等价于a&(~a+1)
常用库函数
#include <algorithm>
1.reverse 翻转
翻转一个 vector： reverse(a.begin(), a.end());
翻转一个数组，元素存放在下标 1~n： reverse(a + 1, a + 1 + n);
int a[]={1,2,3,4,5};
reverse(a,a+5);//取到最后一个元素的下一个
2.unique 去重
前提：相同元素必须挨在一起
返回去重之后的尾迭代器（或指针），仍然为前闭后开，即这个迭代器是去重之后末尾元素的下一个位置。该函数常用于离散化，利用迭代器（或指针）的减法，可计算出去重后的元素个数。
把一个 vector 去重： int m = unique(a.begin(), a.end()) – a.begin(); 把一个数组去重，元素存放在下标 1~n： int m = unique(a + 1, a + 1 + n) – (a +1)；
数组去重处理：
vector<int> a({1, 1, 2, 2, 3, 3, 4});
sort(a.begin(), a.end()); // 对向量进行排序
a.erase(unique(a.begin(),a.end()),a.end());//去除重复的元素之后剩下的数组
for (auto x:a) cout << x << ' ';
3.random_shuffle 随机打乱
#include <algorithm>
#include <ctime>
int main() {
vector<int> a({1, 2, 3, 4, 5});
srand(time(0));//设置种子，通常传入时间作为随机
random_shuffle(a.begin(),a.end());
for(auto x:a) cout<<x<<' ';
return 0;
}
4.sort排序
对两个迭代器（或指针）指定的部分进行快速排序。可以在第三个参数传入定义 大小比较的函数，或者重载“小于号”运算符。
vector<int> a({4, 3, 2, 1, 5});
sort(a.begin(),a.end());
for(auto x:a) cout<<x<<' ';
bool cmp(int a,int b){//a是否应该排在b的前面
return a>b;
}
int main() {
vector<int> a({4, 3, 2, 1, 5});
sort(a.begin(),a.end());//从小到大排
for(auto x:a) cout<<x<<' ';
sort(a.begin(),a.end(),greater<>());//从大到小排
for(auto x:a) cout<<x<<' ';
sort(a.begin(),a.end(),cmp);//自定义排序
for(auto x:a) cout<<x<<' ';
return 0;
}
比较结构体：
struct Rec {
int x, y;
};//
bool cmp(Rec a, Rec b) { //a是否应该排在b的前面
return a.x < b.x;
}
int main() {
Rec a[5];
for (int i = 0; i < 5; i++) {
a[i].x = -i;
a[i].y = i;
}
for (int i = 0; i < 5; i++) printf("(%d,%d)", a[i].x, a[i].y);
cout<<endl;
sort(a, a + 5,cmp);
for (int i = 0; i < 5; i++) printf("(%d,%d)", a[i].x, a[i].y);
return 0;
}
5.lower_bound/upper_bound 二分
lower_bound 的第三个参数传入一个元素 x，在两个迭代器（指针）指定的部分上执行二分查找，返回指向第一个大于等于 x 的元素的位置的迭代器（指针）。 upper_bound 的用法和 lower_bound 大致相同，唯一的区别是查找第一个大于x 的元素。当然，两个迭代器（指针）指定的部分应该是提前排好序的。
int a[] = {1, 2, 4, 5, 6};
int *p = lower_bound(a, a + 6, 3);
cout << *p << endl; //返回值
int t = lower_bound(a, a + 6, 3)-a;
cout << t << endl; //返回下标
vector<int> a{1,2,3,4,5,6};
int t= lower_bound(a.begin(),a.end(),3)-a.begin();
cout<<a[t]<<endl;
6.next_permutation()
next_permutation（start,end），和prev_permutation（start,end）。这两个函数作用是一样的，区别就在于前者求的是当前排列的下一个排列，后一个求的是当前排列的上一个排列。
当当前序列不存在下一个排列时，函数返回false，否则返回true;
vector<vector<int>> res;
do{
res.push_back(nums);
}while(next_permutation(nums.begin(),nums.end()));
return res;
1695
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
