LeetCode 牛客网 C++ 算法 刷题必备基础知识 {ignore}

main综合模板

#include <iostream>         //C++中输入输出函数 cout endl 等
#include <cstring>          //string相关函数操作
#include <stdio.h>          //C语言输入输出函数 printf scanf 等
#include <string.h>         //C语言string操作函数 strlen strcmp等
#include <stdlib.h>         //标准C库函数
#include <sstream>          //文件流操作
#include <math.h>           //标准数学函数  max  min  pow等
#include <vector>           //向量(vector) 容器
#include <deque>            //双端队列(deque)容器
#include <queue>            //队列(FIFO)  容器
#include <stack>            //堆(STACK) 容器
#include <algorithm>        //向量vector排序sort  反转reverse 等函数
#include <unordered_set>    //字典相关
#include <map>              //hashmap容器using namespace std;int main(void)
{return 0;
}

数组排序库

int a[5] = {1, 3, 4, 2, 5};
sort(a, a + 5);

字符串库

#include <string>string s;
int pos = s.find("afsd");        //在s串中查找指定串, 返回值为查找的串在string中的首部索引 没有找到的话返回 string::npos
int pos = s.find("afsd", 5)     //从字符串s 下标5开始，查找字符串b ,返回b 在s 中的索引
string s2 = s.substr(2, 5);     //substr(startPosition,lenth)
string s2 = s.substr(2);        //截取从[2,string::npos)  从当前索引到string结尾
s.c_str();                      //将string对象转化为字符串s += 'a';                       //字符串末尾增加字符'a'
s.push_back('a');               //字符串末尾增加字符'a'
s.pop_back();                   //字符串中删除最后一个元素int atoi(s.c_str());            //C/C++将字符串转化为整数
int stoi(const strings str /*, size_t* pos = 0, int base = 10 */)   //将string转化为int，后续两个为可选参数pos返回无法实现转换的字符索引，base设置转换的进制，比如十进制base=10,八进制base=8
long stol(const strings str /*, size_t* pos = 0, int base = 10 */)  //将string转化为long
float stof(const strings str /*, size_t* pos = 0 */)                //将string转化为float
double stod(const strings str /*, size_t* pos = 0 */)               //将string转为为double
string to_string(int value);        //int转化为string
string to_string(long value);       //long转化为string
string to_string(double value);     //double转化为stringgetline(cin, s);   //输入一行，不被空格打断

迭代器

迭代器（Iterator）是一种检查容器内元素并遍历元素的数据类型。迭代器是指针的泛化，它允许程序员用相同的方式处理不同的数据结构（容器）。
各种容器类型中 stack queue priority_queue 不支持迭代器。

容器类名::iterator 迭代器名；       //迭代器定义方法
vector<int> s(100);             //创建100个元素的vector容器
vector<int>::iterator it = s.begin();   //定义一个迭代器it，指向vector<int>类型的容器首个元素
*it         //代表首个元素的值
*it = 23;   //将s的首个元素赋值为23；
it++;       //it指向s[1]，向右偏移一个元素
it--;       //it又指回s[0]，向左偏移一个元素
it += 10;   //向后偏移10个元素
it -= 10;   //向前偏移10个元素

向量vector

vector是一个顺序容器，顺序容器中的元素按照严格的线性顺序排序，可以通过元素在序列中的位置访问对应的元素。
vector支持对序列中的任意元素进行快速直接访问，甚至可以通过指针算述进行该操作。操供了在序列末尾相对快速地添加/删除元素的操作。
由于vector的存放机制，导致其可以快速随机读取，并在尾部快速插入/删除元素。但如果在首部、中间插入元素则比较费时，因为后面的元素都要相应右移；
vector在初始化时，会提前分配一个较大的内存空间用于vector对象拓展，当对象拓展将要超越预分配的内存大小时，vector会重新分配一个原来两倍大小的内存，将所有数据拷贝到新内存中，释放原来的内存。这都是非常耗时的。

vector初始化

int a[5] = {1, 2, 3, 4, 5};
vector<int> s(a, a+5);  //将数组元素初始化为vector中的元素
vector<vector<int>> s(A, vector<int>(B));   //创建s[A][B]大小的二维向量std::vector<int> v1(3);                                 // 1. Create a vector v1 with 3 elements of default value 0
std::vector<int> v2(5, 2);                              // 2. Create a vector v2 with 5 elements of value 2
std::vector<int> v3(3, 1, v2.get_allocator());          // 3. Create a vector v3 with 3 elements of value 1 and with the allocator of vector v2
std::vector<int> v4(v2);                                // 4. Create a copy, vector v4, of vector v2
std::vector<int> v5(v4.begin() + 1, v4.begin() + 3);    // 5. Create a vector v5 by copying the range v4[_First, _Last)

vector方法

#include <vector>vector<int> s;            //向量是一串数据组
s.size();                 //反回栈的大小
vec.capacity();           //容器容量，指在发生 realloc 前能允许的最大元素数，即预分配的内存空间，与size()不同
vec.max_size();           //容器最大容量
vec.resize(10);           //将现有元素个数调整至10个，多则删，少则补，其值随机
s.resize(10,2);           //将现有元素个数调整至10个，多则删，少则补，其值为2
s.reserve(100);           //将容量扩充至100，原值保持不变，多则删，少则补
bool = s.empty();         //判断向量是否为空 如果为空，返回trues[1];                     //下标访问，并不会检查是否越界
s.at(1);                  //at方法访问，检查是否越界，是则抛出 out of range 异常
int* p = s.data();        //返回一个指针指向这个数组
s.pop_back(const T& x);   //弹出向量的尾部元素，并不返回任何值
s.push_back(const T& x);  //压入新的元素到向量的尾部
<int> = s.front();        //访问向量最前的元素
<int> = s.back();         //访问向量最后的元素
s.begin();                //起始位置迭代器值；
s.end();                  //指向最后一个元素的下一个位置迭代器值
s.clear();                //清空整个向量
s.insert( s.begin() + n, <int>);    //在向量中第n个索引元素前插入<int>
vector<int> s2;
s.insert( s.begin() + n, s2.begin(), s2.end());    //在向量中第n个索引元素前插入同类的s2向量
s.erase(s.begin() + n);         //删除向量中的第n个索引元素
s.erase(s.begin() + n, s.begin() + m);     //删除向量中的[n,m)区间的元素
if(find(s.begin(), s.end(), int) == s.end()){}  //在vector s中查找是否有某个元素，如果有，返回指针类型 vector<int>::iterator

Vector 排序

//注意包含头文件#include <algorithm>
sort(s.begin(), s.end());   //默认升序排列bool sortFun(int & x, int & y)
{return x < y;   //升序排列//return x > y;    //降序排列
}
sort(num.begin(), num.end(), sortFun);  //按照sortFun制定的规则排序
reverse(s.begin(), s.end());            //颠倒vector s中的所有元素，倒序

双端队列deque基本用法

deque是由一段一段的定量连续空间构成，可以向两端发展，因此不论在尾部或头部安插元素都十分迅速。 在中间部分安插元素则比较费时，因为必须移动其它元素。
deque在开始位置和结束位置的插入删除操作的时间是固定的。如果多数操作发生在起始和结束位置，优先使用deque。

deque初始化

#include <deque>deque<int> a;           // 定义一个int类型的双端队列a
deque<int> a(10);       // 定义一个int类型的双端队列a，并设置初始大小为10
deque<int> a(10, 1);    // 定义一个int类型的双端队列a，并设置初始大小为10且初始值都为1
deque<int> b(a);        // 定义并用双端队列a初始化双端队列b
deque<int> b(a.begin(), a.begin()+3); // 将双端队列a中从第0个到第2个(共3个)作为双端队列b的初始值int n[] = { 1, 2, 3, 4, 5 };
deque<int> a(n, n + 5);     // 将数组n的前5个元素作为双端队列a的初值，这个主要是为了和deque.end()指针统一。
deque<int> a(&n[1], &n[4]); // 将n[1]、n[2]、n[3]作为双端队列a的初值

deque方法

#include <deque>deque<int> deq;
deq.size();     //容器大小
deq.max_size(); //容器最大容量
deq.resize(int);   //更改容器大小
deq.empty();    //容器判空
deq.shrink_to_fit();    //减少容器大小到满足元素所占存储空间的大小deq.push_front(const T& x);    //头部添加元素
deq.push_back(const T& x);     //末尾添加元素
deq.insert(iterator it, const T& x);   //任意位置前插入一个元素
deq.insert(iterator it, int n, const T& x); //任意位置前插入 n 个相同元素
deq.insert(iterator it, iterator first, iterator last); //插入另一个向量的 [forst,last] 间的数据deq.pop_front();    //头部删除元素
deq.pop_back();     //末尾删除元素
deq.erase(iterator it); //任意位置删除一个元素
deq.erase(iterator first, iterator last);   //删除 [first,last] 之间的元素
deq.clear();        //清空所有元素deq.front();    //访问第一个元素
deq.back();     //访问最后一个元素
deq[1];         //下标访问，并不会检查是否越界
deq.at(1);      //下标访问，检查是否越界deq.begin();    //开始迭代器指针
deq.end();      //末尾迭代器指针

队列queue的基本用法

queue数据结构没有迭代器，不能进行随机访问。且只能在尾部push添加元素，在首部pop取出元素。

#include <queue>queue<int> s;   //队列是先入先出的FIFO
s.front();      //队列首元素  只能通过front 和 back 接口访问首尾元素，无法访问中间元素
s.back();       //队列尾元素
s.pop();        //弹出队列的首元素
s.push();       //压入新的元素
s.size();       //反回队列的大小
s.empty();      //判断queue是否为空
s = queue<int>();   //清空队列，通过赋值空队列的方式清空

堆stack的基本用法

#include <stack>stack<int> s;   //堆是后入先出
s.top();        //堆顶元素  只能使用top访问顶部元素 无法访问中间元素
s.pop();        //弹出堆的顶元素，并不反回任何值，仅弹出元素
s.push();       //压入新的元素
s.size();       //反回栈的大小
s.empty();      //判断堆是否为空

双向链表list基本用法

list 由双向链表（doubly linked list）实现而成，元素也存放在堆中，每个元素都是放在一块内存中，他的内存空间可以是不连续的，通过指针来进行数据的访问，这个特点使得它的随机存取变得非常没有效率，因此它没有提供 [] 操作符的重载。但是由于链表的特点，它可以很有效率的支持任意地方的插入和删除操作。

#include <list>list<int> s, s1;        //创建链表
list<int> s(10);    //创建包含10个元素值为0的链表
list<int> s(10,6);  //创建包含10个元素值为6的链表
list<int> s(s1);    //创建一个与s1相同的链表
list<int> s(s1.begin(), s1.begin() + 3);    //创建包含s1头四个元素的链表
int n[] = { 1, 2, 3, 4, 5 };
list<int> s(n, n + 5); // 将数组n的前5个元素作为列表a的初值s.size();           //容器大小
s.max_size();       //容器最大容量
s.resize();         //更改容器大小
s.empty();          //判断链表是否为空s.push_front(const T& x);  //在链表头插入元素
s.push_back(const T& x);   //在链表尾部插入元素
s.pop_front();      //删除头部元素
s.pop_back();       //删除尾部元素
s.front();          //返回首部元素
s.back();           //返回尾部元素
s.clear();          //清空链表
s.erase(s.begin() + i);     //删除链表中索引为i的元素
s.insert(s.begin() + i, (int)a);    //在链表的索引为i的位置插入a
s.insert(s.begin() + i, s1.begin() + j, s1.begin() + k);    //将s1的[j,k]元素插入到
s.sort();           //将链表中的元素进行排序
s.reverse();        //将链表中的元素倒转
s.unique();         //删除链表中重复的元素s.begin();          //开始迭代器指针
s.end();            //末尾迭代器指针

hashmap的基本用法(构建一 一映射的关系)

map由红黑树实现，其元素都是 “键值/实值” 所形成的一个对组（key/value pairs）。每个元素有一个键，是排序准则的基础。每一个键只能出现一次，不允许重复。

#include <map>map<k, v> m;       //定义了一个名为m的空的map对象 其中的key为k 值为v
map<k, v> m2(m);    //创建了m的副本m2
map<k, v> m3(m.begin() + b, m.begin() + e); //创建了map对象m3，并且存储迭代器b和e范围内的所有元素的副本//例：
map<string , int> m;  //key为一个string 值为一个int
m["ABC"] = 123;       //在m中创建了一个映射关系 通过key值 "ABC" 可查找到int值 123   注意：使用key值访问一个不存在的元素将会创建新元素
m["DEF"] = 456;       //在m中创建了一个映射关系 通过key值 "DEF" 可查找到int值 456   注意：使用key值访问一个已存在的元素将会覆盖原元素//插入值：
m.insert(pair<string, int>("GHI", 789));            //与m["GHI"] = 789;等效
m.insert(m.begin() ,pair<string, int>("GHI", 789)); //在m的首部插入值
m.insert({ {"ABC", 123 }, {"DEF", 456} });          //列表形式多元素插入m.erase(m.begin());     //删除首部元素
m.erase("ABC");         //删除key值为ABC的元素
mp.pop_back(const T& keyValue); //与erase用法相同map<string, int>::iterator index = m.find("ABC");   //查找key值为"ABC"的元素迭代器值，不存在返回m.end() 通常用法: m.find("ABC") != m.end(); //找到了该元素m.empty();      //是否为空
m.clear();      //清空所有元素
m.size();       //m中元素的个数
m.max_size();   //最多容纳的元素个数
m.swap(m1);     //交换两个map
m.count(key);   //统计key值在map中出现的次数，因为map中key值不允许重复，则map包含key值则返回1，不包含则返回0//map的元素遍历
for(map<string, int>::iterator i = m.begin() ; i != m.end(); i++)
{int key = i -> first;       //访问这个元素的keyint val = i -> second;      //访问这个元素的val
}
//或者
for(auto i : m)
{int key = i.first;  //访问这个元素的keyint val = i.second; //访问这个元素的val
}

奇技淫巧

辗转相除法求最大公约数

int fun(int m,int n)
{if(n==0) return m;return fun(n,m%n);
}

如何判断链表有环，并找出入环点

对于如何判断链表有环，可以从起点发出两个指针，一个一次一步，另一个一次两步，如果两个指针相遇，那么这个单链表就有环。
第一问得出相遇点后，再发出一个指针，统计这个指针再次回到这个点的距离，也就是环的距离。然后从起点再发出两个指针，一个指针在另一个前面，两个指针的距离就是环的距离，当两个指针再次相遇的时候就是环的入口。

异或运算 可以快速判断多个项的相等结果

c = a⊕b //如果a、b两个值不相同，则异或结果为1。如果a、b两个值相同，异或结果为0
(a⊕b)⊕c = a⊕(b⊕c)
在判断数值是否相同时，可以通过异或运算快速判断

LeetCode 牛客网 C++ 算法 刷题必备基础知识相关推荐

1. python刷题 NOI题库 python题解 洛谷、牛客网、AcWing 刷题等

   NOI题库 python题解-2022.01.07整理(1.1-1.3) NOI题库 python题解-2022.01.07整理(1.1-1.3)_dllglvzhenfeng的博客-CSDN博客 N ...

2. 洛谷、牛客网、AcWing 刷题（python版）

   牛客网python专项练习整理(一) https://blog.csdn.net/weixin_41913008/article/details/87203468 牛客网剑指offer--python ...

3. 牛客网c语言刷题130，开篇入门刷题，战胜对编程的恐惧，适合初学者食用。

   大一,大二初学者训练题 1. BC1-实践出真知 2. BC2-我是大V 3. BC3-有容乃大 4. BC7-缩短二进制 5. BC19-反向输出一个四位数 6. BC28- 大小写转换 本文所有题 ...

4. 牛客网SQL篇刷题篇（38-47）

   1.视图:视图是可视化的表. 视图的作用: 第一点:使用视图,可以定制用户数据,聚焦特定的数据. 解释: 在实际过程中,公司有不同角色的工作人员,我们以销售公司为例的话, 采购人员,可以需要一些与其有 ...

5. 牛客网SQL篇刷题篇（32-37）

   https://www.nowcoder.com/ta/sql 1.sql group_contact().concat().concat_ws函数 https://blog.csdn.net/qq_ ...

6. 牛客网SQL篇刷题篇（24-31）

   https://www.nowcoder.com/ta/sql 1.NOT IN NOT IN运算符允许从结果集中排除特定值的列表. 2.sql子查询 https://www.cnblogs.com/ ...

7. 牛客网SQL篇刷题篇（16-23）

   https://www.nowcoder.com/ta/sql 1.SQL嵌套查询 https://www.cnblogs.com/glassysky/p/11559082.html (1)什么是嵌套 ...

8. 牛客网SQL篇刷题篇（3-10）

   https://www.nowcoder.com/ta/sql 1.inner join 和left join (1)在表中存在至少一个匹配时,INNER JOIN 关键字返回行. SELECT ** ...

9. 牛客网SQL篇刷题篇（1-2）

   https://www.nowcoder.com/ta/sql

最新文章

1. CentOS重启启动Apache,VNC
2. 橡皮筋模型不太对呀？！
3. ENTBOOST V1.0 发布，开源企业IM免费企业即时通讯
4. 李飞飞的斯坦福 HAI 招人了，薪资丰厚科研经费管够
5. C++ sizeof总结
6. ubuntu opengl 安装
7. [转载] java clone方法_Java Calendar clone（）方法与示例
8. 【DP】LeetCode 120. Triangle
9. 跟工作选择障碍同学聊一聊现实的问题……
10. Ubuntu系统---C++之Eclipse IDE 编译器安装
11. 咸鱼Maya笔记—初识Maya 2019
12. (转)War3 地图编辑器脚本接口说明
13. 全面解析NFT的流动性问题与解决方案
14. Lecture3 损失函数和优化损失函数
15. JFrog Artifactory的数据备份与恢复教程
16. 美企暂停俄罗斯业务，凸显国内企业阿里等自研操作系统前瞻性
17. 全球及中国PTA（纯对苯二甲酸）市场竞争力及投资可行性分析报告2022～2028年
18. 前端安全系列：如何防止XSS攻击？
19. ＧＢ２３１２汉字编码
20. 中控屏成智能家居新宠？

热门文章

1. ESP8266开发之旅 阿里云物联网平台篇② MQTT.FX客户端模拟 调试 MQTT LED智能灯控制系统
2. GSP-广义第二计费
3. Docker构建python环境
4. 推荐考察系统“双管齐下”，提高考察工作效率
5. win10电脑禁止启动某软件
6. apache httpd下载安装步骤
7. 数据库系统的概念及其四大特点
8. 【推荐】华为顶级认证HCIE-RS培训教材全套合集
9. python爬虫获取强智科技教务系统学科成绩（模拟登录+成绩获取）
10. 2014-03-29.阿里实习生招聘笔试题目