leetcode刷题-c++语法基础
pair
std::pair 是一个用来存储两个值的简单容器。它的两个值可以是相同类型或者不同类型。std::pair 是定义在头文件
是std::map 和 std::unordered_map 中的元素
'''
std::pair<int, std::string> myPair(100, "example");
// 可以使用 make_pair 快速创建 pair 对象，（在 C++11 及以后的版本中，通常你可以略去 make_pair，直接使用花括号初始化）。
auto anotherPair = std::make_pair(42, "Hello World");
std::map<int, std::string> myMap;
// 向 map 中插入元素时，元素是 std::pair 类型
myMap.insert(std::make_pair(1, "One"));
myMap.insert(std::pair<int, std::string>(2, "Two"));
myMap[3] = "Three";
// 用 auto & 遍历 map
for (const auto &pair : myMap) {
std::cout << "Key: " << pair.first << "; Value: " << pair.second << std::endl;
'''
new
在 C++ 中，new 关键字用于在堆（heap）上动态分配内存。这与在栈（stack）上分配内存相对，后者通常通过声明局部变量实现。使用 new 可以在程序运行时根据需要分配确切数量的内存，并且这部分内存会一直保留，直到显式地使用 delete 关键字进行释放。
TreeNode* p=new TreeNode(10) // 创建一个节点并调用初始化
TypeName* pointer = new TypeName; //分配单个对象的内存：
TypeName* pointer = new TypeName(arguments);// 分配一个对象并调用其构造函数（如果有参数）
TypeName* pointer = new TypeName[10] ; // 分配10个对象的组
int* myInt = new int; // 分配内存用于存储一个int值
float* myFloat = new float(3.14f); // 分配内存并初始化为3.14
int* myArray = new int[10]; // 分配一个10个int元素的数组
int* myArray = new int[5]{1, 2, 3, 4, 5}; // 分配并初始化一个整数数组
delete ptr; // 释放单个对象
delete[] arr; // 释放数组：
vector
常用size() empty() front() back() push_back() pop_back() emplace_back()
insert(const_iterator position, const value_type& val)：在迭代器 position 前插入 val。
erase(const_iterator position)：移除 position 位置的元素。
erase(const_iterator first, const_iterator last)：移除区间 [first, last) 内的所有元素。
clear() noexcept：移除 vector 中的所有元素。
初始化
std::vector<int> v1; // 一个空的整数 vector
std::vector<int> v2(10); // 一个大小为10的整数 vector，所有元素都是0
std::vector<int> v3(10, 42); // 一个大小为10的整数 vector，所有元素都是42
std::vector<int> v4 = {1, 2, 3, 4, 5}; // 使用初始值列表的 vector 初始化
std::vector<int> v4{1, 2, 3, 4, 5}; // 或者省略等号
std::vector<vector<int>> g(n, vector<int>(n, inf)); // 二维数组
vector.resize
改变大小和开辟空间
// 将vector扩大至5个元素，默认新元素值为0
vec.resize(5);
// 用特定值10重新调整vector大小，将大小改为7
vec.resize(7, 10);
// 初始化二维矩阵
vec.resize(m, vector<int>(n)); //第一个行数，第二个每行的内容
vector之间复制
//vector用其他vector初始化
vector<int> repeat(nums);
vector<int> repeat(nums.begin(), nums.end());
// 确保 b 有足够空间来存放新内容
b.resize(3); // 选择 3 作为目标大小因为我们想要复制 3 个元素
//使用 assign 复制范围内的元素
b.assign(a.begin() + 2, a.begin() + 5);
// 使用 std::copy 复制范围内的元素
std::copy(a.begin() + 2, a.begin() + 5, b.begin());
priority_queue
优先队列，默认大顶堆，常用成员函数push top pop empty
初始化
priority_queue<int> pq;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> q; //默认按照pair的<运算排序，按照第一个排，第一个相同再按第二个排列
控制排序
方式1 定义比较函数
class Solution {
public:
ListNode* mergeKLists(vector<ListNode*>& lists) {
int size = lists.size();
// 虚拟头结点
ListNode* dummy = new ListNode(-1);
ListNode* p = dummy;
// 优先级队列，最小堆
priority_queue<ListNode*, vector<ListNode*>, compare > pq;
// 将 k 个链表的头结点加入最小堆
for (auto head : lists) {
if (head) pq.push(head);
}
while (!pq.empty()) {
// 获取最小节点，接到结果链表中
auto node = pq.top();
pq.pop();
p->next = node;
if (node->next) {
pq.push(node->next);
}
// p 指针不断前进
p = p->next;
}
return dummy->next;
}
private:
// 自定义比较函数
struct compare {
bool operator() (ListNode* a, ListNode* b) {
return a->val > b->val; // 降序
}
};
};
方式2 lambda
priority_queue<ListNode, vector<ListNode>,[](ListNode a, ListNode b){
return a->val > b->val;} > pq;
push和emplace差异
结果一样，不过emplace直接容器内构建，还有emplace（）可以直接传入构造参数不用实例
priority_queue<pair<int, int>> q;
q.push(pair<int,int>(nums[i], i));
q.emplace(nums[i], i);
unordered_set
哈希集合，无排序（和set不一样），不重复
常用成员函数insert emplace count empty erase size clear
unordered_map
// 创建并初始化一个 unordered_map
std::unordered_map<std::string, int> myMap = {
{"apple", 2},
{"banana", 3},
{"orange", 4}
};
// 插入新的键值对
myMap["pear"] = 1;
// 删除元素
myMap.erase("orange");
//查找key是否存在
myMap.count(“apple”): //0不在,1存在
// 检查元素是否存在，如果存在，输出其数量
if(myMap.find("banana") != myMap.end()) {
std::cout << "banana count: " << myMap["banana"] << std::endl;
}
// 使用迭代器遍历 unordered_map
for (const auto& pair : myMap) {
std::cout << pair.first << ": " << pair.second << std::endl;
}
for(auto it = myMap.begin(); it != myMap.end();it++){
std::cout << it->first << ": " << it->second << std::endl;
}
// 获取 unordered_map 的大小
std::cout << "Size: " << myMap.size() << std::endl;
string
sting find
size_t find(const std::string& str, size_t pos = 0) const;：查找 str 字符串从位置 pos 开始的第一次出现。
std::string str = "Hello, World!";
std::string toFind = "World";
// 查找子字符串 "World"
size_t pos = str.find(toFind);
if (pos != std::string::npos) {
std::cout << "Found 'World' at position: " << pos << std::endl;
} else {
std::cout << "'World' not found!" << std::endl;
}
string清空
1.s.clear()
2.s.erase();//不带参数就删除所有
3.s.resize(0);
4.s = "";
// 提取从位置 7 开始的全部字符
std::string sub1 = text.substr(7);
// 提取从位置 0 开始的 5 个字符
std::string sub2 = text.substr(0, 5);
容器比较==
Vector undered_map支持==，逐个比较元素 包含大小顺序一样才相等
stack
栈
stack<char> ss
Ss.top()
ss.push(c)
ss.pop()
Ss.empty()
Ss.size()
queue
队列front() push() pop() empty() size()
INT_MAX INT_MIN LONG_MIN LONG_MAX
sort
sort 是一个非常通用和高效的算法，用于对容器中的元素进行排序。它定义在
std::vector<int> vec = {4, 1, 3, 5, 2};
std::sort(vec.begin(), vec.end());
改变排序有三种方式，推荐第二种
1.自定义比较函数
bool compare(int a, int b) {
return a > b; // 降序，如果a大于b就返回true
}
std::sort(vec.begin(), vec.end(), compare);
2.lambda 表达式 c++ 11
std::sort(vec.begin(), vec.end(), [](int a, int b) {
return a > b; // 降序排列
});
3.greater less(默认)
#include <functional> // std::greater<>
std::sort(vec.begin(), vec.end(), std::greater<>());
