LeetCode 刷题基础Ⅰ -- 基础语法
c++ 基础语法，LeetCode 刷题用
学习网站
一、顺序结构
基本数据类型
① 整型 int
范围是从−231到231−1（即从-2147483648到2147483647），简单估算可以认为是绝对值在2∗109以内。
② 长整型 long
范围是从−263到263−1，简单估算可以认为是绝对值在9∗1018以内。
③ 浮点型 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]; // 不行，程序会崩溃，用vector
vector<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;
原文地址：https://blog.csdn.net/2401_83694336/article/details/142498653
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！