LeetCode 刷题基础Ⅰ -- 基础语法

c++ 基础语法，LeetCode 刷题用

学习网站
- 一、顺序结构
- - 基本数据类型
  - - ① 整型 int
    - ② 长整型 long
    - ③ 浮点型 double
    - ④类型转换
  - 输入输出
  - - ① getchar 吸收回车符
    - ② 数学函数
    - ③ 最大值的定义
- 二、选择结构
- - ① switch
- 三、数组
- - ① 初始化
  - ② 输入
  - ③ 方法
- 四、结构体
- - ① 自定义结构体
  - ②自定义cmp
- 五、vector
- 六、set （有序）
- 6.5、unordered_set （无序有 find方法）
- 七、string
- - ① 基础
  - ② 查找
  - ③ 增删
- 八、map
- - ① 基础
  - ② 对键和值的排序
- 九、queue
- 十、priority_queue
- - ① 基础
  - ② 自定义比较方式 1
  - ③ 自定义比较方式 2
  - ④ pair
- 十一、stack
- 十二、pair

学习网站

晴问算法训练营

一、顺序结构

基本数据类型

① 整型 int

范围是从−2³¹到2³¹−1（即从-2147483648到2147483647），简单估算可以认为是绝对值在2∗10⁹以内。

② 长整型 long

范围是从−2⁶³到2⁶³−1，简单估算可以认为是绝对值在9∗10¹⁸以内。

③ 浮点型 double

输出格式为： “%m.nf”

其中 m 表示要输出这个数的宽度，包括小数点，如果实际数值的宽度大于m,则以实际的数据宽度为准，如果实际数值宽度小于m，那么默认右对齐，前面补空格。

n 表示小数点后面数据的位数。

double 另一种输出格式为： %mf （不管小数点后面的）

m表示要输出这个数的宽度，包括小数点，如果实际数值的宽度大于 m，则以实际的数据宽度为准，如果实际数值宽度小于m,那么默认右对齐，前面补空格

注意：对于浮点型变量，小数点后默认有6位小数。

对于四舍五入问题：

④类型转换

int a, b;
double ans = (double)a / b;double d = 5.5;
int i = static_cast<int>(d);  // i = 5

输入输出

① getchar 吸收回车符

② 数学函数

数学函数都在cmath头文件下，以下是本题涉及的常见数学函数，它们都接收浮点型，返回的也是浮点型。

fabs(a)：a的绝对值
floor(a)：a的向下取整
ceil(a)：a的向上取整
round(a)：a的四舍五入（实际是四舍六入五成双）
pow(a, b)：a的b次方，其中b也可以是浮点型
sqrt(a)：a的算术平方根（即开根号）
log(a)：a的以自然对数e为底的对数

// max 3
int main() {int a, b, c;cin >> a >> b >> c;cout << max({a, b, c});return 0;
}

③ 最大值的定义

Max = --1e9;
Min = 1e9;

二、选择结构

① switch

三、数组

① 初始化

int num[1000] = {0};
int a[100][100];  //可以
int a[1000][1000];   // 不行，程序会崩溃，用vectorvector<vector<int> > A;	//正确的定义方式，后面的尖括号前要加上空格
vector<vector<int>> A;	//c++11之前这样定义是错误的，c++11之后支持这种定义方式int a[100];
memset(a, 0, sizeof(a));fill(a, a + n, k);int n = 3, m = 5, k, a[3][5];
fill(&a[0][0], &a[0][0] + n * m, k);

② 输入

// 输入整行 1
const int MAX_LEN = 51;
char str[MAXN];
cin.getline(str, MAXN_LEN);// 输入整行 2
string st;
getline(cin,st);

cin.getline函数在输入整行字符串的时候是以换行符\n为结束判断标志，并且在结束时会把这个\n给舍弃掉。因此我们在使用cin.getline输入一行字符串之后，再次使用cin.getline即可输入下一行字符串。

③ 方法

//二分查找数组中第一个大于等于某个数的位置
auto bound = lower_bound(sums.begin(), sums.end(), target);  //sum

四、结构体

① 自定义结构体

// 单链表
struct ListNode {int val;ListNode *next;ListNode() : val(0), next(nullptr) {}ListNode(int x) : val(x), next(nullptr) {}ListNode(int x, ListNode *next) : val(x), next(next) {}
};ListNode* pre = new ListNode(0,head);
ListNode* p = new ListNode();

②自定义cmp

//自定义cmp
struct Node{int x,y;Node(int x,int y): x(x),y(y) {}
};
bool cmp(Node a,Node b){if(a.x!=b.x){return a.x<b.x;}else{return a.y<b.y;}
}
int main(){sort(a,a+n,cmp);
}

五、vector

可变长度的数组。无find函数

// 定义、初始化
vector<int> vi;
vector<int> v(n, k);       // n 指长度， k 指每个元素的值
vector<int> v(n);          // n 指长度，每个单元初始化为 0
vector<int> v[n];          // 定义了一个长度为 n 的数组，数组的每个元素都是一个 vector 类型的变量。// 压入压出
vi.push_back(m);
vi.pop_back();// 输出
for(int i = 0; i < vi.size(); i++){cout<<vi[i];
}// 清空
vi.clear();// 插入到第 k 个位置，或删除第 k 个位置
vi.insert(vi.begin() + k, x);  
vi.erase(vi.begin() + k);// 排序 sort
sort(ans.begin(),ans.end());// 二维
vector<vevtor<int>> ans;
vector<int> v;
v.push_back(k);
....
ans.push_back(v);
ans[0].push_back(k);

六、set （有序）

set：可变长度，从小到大自动排序，唯一，有count()、find()

// 定义、初始化
set<int> s;
// 压入压出
s.insert(x);// 输出
for (set<int>::iterator it = s.begin(); it != s.end(); it++) {cout<<*it;
}
// 清空
s.clear();// 查找，与删除指定元素
set<int>::iterator it = s.find(k);
if(it != s.end()){s.erase(it);
}// 删除第 k 个位置
s.erase(k);

6.5、unordered_set （无序有 find方法）

弥补 vector 的无 find 不足

// 查找
unordered_set<ListNode *> visited;
ListNode *temp = headA;
visited.insert(temp)      //插入为insert 
visited.count(temp)     //  元素存在于容器中，则此函数返回1，否则返回0。visited.find(x) != visited.end()

七、string

① 基础

// 定义
string s;// 输入输出
cin>>s;      
getline(cin,s);      // 输入整行cout<<s;// 拼接
string s1,s2,s3;
s3 = s1 + s2;// 比较
看字典序的// 清空
s.clear();// 获取从s的下标从 k 开始、长度为 len 的子串
s2 = s.substr(k,len);//s1的下标从k开始、长度为len的子串替换为另一字符串s2，赋值s3；
s3 = s1.replace(k,len,s2);

② 查找

// 断s2 是否是 s1 的子串, 如果是的话，输出 s2 第一次在 s1 中出现的起始位置；如果不是，那么输出-1。
int pos = s1.find(s2);//从下标position位置处开始查 str
find(str,position)  //找到目标字符的位置
string s = "hello world!";
cout << s.find("e") << endl;  //输出结果：1//未找到目标字符
string s = "hello world!";
if (s.find("a") == s.npos) {cout << "not found" << endl;  //输出结果：not found
}//查找 ‘a’ 的个数int num = count(s.begin(),s.end(),'a');

③ 增删

// 插入到第 k 个位置，或删除
s.insert(vi.begin() + k, c);  
s.erase(vi.begin() + k);erase(pos,n);  //删除从pos开始的n个字符，比如erase(0,1)就是删除第一个字符
erase(position);  //删除position处的一个字符(position是个string类型的迭代器)
erase(first,last);  //删除从first到last之间的字符（first和last都是迭代器）

八、map

① 基础

// 定义、初始化
map<char, int> mp;     // <key, value> , 任意类型// 输入
mp[c] = x;// 输出
for (map<char, int>::iterator it = mp.begin(); it != mp.end(); it++) {cout << it -> first << " " << it -> second << endl;
}// 清空
mp.clear();// 查找键
if (mp.find(c) != mp.end()) {cout << mp[c];
}// 删除键
mp.erase(c);

② 对键和值的排序

// map 实现对 键key 排序
class MyCompare {
public:bool operator()(int v1, int v2) const {return v1 > v2;}
};void test01() {//默认从小到大排序//利用仿函数实现从大到小排序map<int, int, MyCompare> m;m.insert(make_pair(1, 10));m.insert(make_pair(2, 30));m.insert(make_pair(3, 50));for (map<int, int, MyCompare>::iterator it = m.begin(); it != m.end(); it++) {cout << "key:" << it->first << " value:" << it->second << endl;}
}// map 实现对 值 排序
class Solution {
private:typedef pair<string, int> PAIR;static bool cmp_val(const PAIR& left, const PAIR& right) {return left.second > right.second;}public:vector<int> topKFrequent(vector<int>& nums, int k) {map<string, int> mp;for (int i = 0; i < nums.size(); i++) {   // 记录数组元素和出现的次数mp[to_string(nums[i])]++;}vector<PAIR> cnt(mp.begin(), mp.end());   // sort一下sort(cnt.begin(), cnt.end(), cmp_val);vector<int> ans;for (int i = 0; i < k; ++i) {             // 输出前 k 个int x = atoi(cnt[i].first.c_str());ans.push_back(x);}return ans;}
};

九、queue

// 定义、初始化
queue<int> q;// 压入压出
q.push(k);
q.pop();// 输出 队首和队尾
cout<<q.front()<<" "<<q.back();// 清空，和判空
vi.clear();
if(q.empty())

十、priority_queue

① 基础

// 定义、初始化
priority_queue<int> q;   //默认值越大优先级约高, 递减
priority_queue<int, vector<int>, greater<int> > q1;  // 递增// 压入压出
q.push(x); q.pop()// // 输出 队首
cout << q.top();// 清空，和判空
vi.clear();
if(q.empty())

② 自定义比较方式 1

// 结构体 // 在结构体Fruit内部重载 < 操作符，对两个 Fruit 变量 f1 与 f2，// 当 f1.price > f2.price 时认为 f1 < f2成立；
struct Fruit {string name;int price;Fruit(string _name, int _price) {name = _name;price = _price;}friend bool operator < (Fruit f1,Fruit f2) {return f1.price > f2.price;}
};int main() {priority_queue<Fruit> q;for (int i = 0; i < n; i++) {cin >> name >> price;q.push(Fruit(name, price));}Fruit topFruit = q.top();cout << topFruit.name << " " << topFruit.price;return 0;
}

③ 自定义比较方式 2

struct fruit
{string name;int price;
};struct myComparison
{bool operator () (fruit f1,fruit f2){return f1.price > f2.price;}
};//此时优先队列的定义应该如下
priority_queue<fruit,vector<fruit>,myComparison> q;

④ pair

//pair
priority_queue<pair<int, int> > a;      //默认对值即 a.second 进行排序
pair<int, int> b(1, 2);
pair<int, int> c(1, 3);
pair<int, int> d(2, 5);
a.push(d);
a.push(c);
a.push(b);
while (!a.empty()) 
{cout << a.top().first << ' ' << a.top().second << '\n';a.pop();
}
//输出结果为：
2 5
1 3
1 2

十一、stack

// 定义、初始化
stack<int> s;// 压入压出
s.push(x); s.pop();// 输出 栈顶
s.top();

十二、pair

// 定义、初始化
string str; int k;
pair<string, int> p = make_pair(str, k);// 输出
cout << p.first << " " << p.second;