榎aaaa的个人主页

Hello

Sun, 19 Apr 2026 14:37:20 +0800

榎 aaaa

Fundamentals of Cpp：现代 C++ 核心笔记

Sun, 19 Apr 2026 00:00:00 +0000

涵盖从 C++11 到 C++23 的核心特性，包含内存管理、RAII 及底层架构思考。

Mon, 01 Jan 0001 00:00:00 +0000

第九十四题：二叉树的中序遍历

非常基础的一个遍历，感觉没什么好说的….

首先确定递归函数的参数和返回值：void–因为这里直接传入了一个vector的引用

然后明确递归终止的条件：当前节点为空

这也就意味着当前分支上的所有节点都已经遍历完了，所以应该进入下一个分支

比如中序遍历，顺序是“左中右”，所以inorder函数中就是先递归左分支，再将中间节点压入vector，最后遍历右分支

其他两个遍历以此类推

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


void inorder(TreeNode* root, std::vector<int>& traversal)
{
 if(root == NULL) return;
 inorder(root->left, traversal);
 traversal.push_back(root->val);
 inorder(root->right, traversal);
}

vector<int> inorderTraversal(TreeNode* root)
{
 std::vector<int> traversal;

 inorder(root, traversal);
 return traversal;
}

第一百零一题：对称二叉树

要判断一个二叉树是否对称，就是判断这个树根节点的左右子树是否能够翻转，而判断能否翻转，则需要判断这棵二叉树的内外侧节点是否相同

因为需要拿到左右子树各自的信息，所以使用后序遍历

首先对特殊情况进行判断：

1.传入的左节点不为空，右节点为空，那么无法翻转

2.左空右不空同理

3.两边都为空时，可以翻转

4.两遍都不为空，但是值不同，不能翻转

5.只有当两者都不为空且值相等时，才进入递归逻辑，判断左子树的左节点与右子树的右节点能否翻转（外侧），以及左子树的右节点与右子树的左节点能否翻转（内侧）

最后，只有当左右节点都能反转时，才可以认为这棵树 / 子树能翻转

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


bool Compare(TreeNode* left, TreeNode* right)
 {
 if(!left && right) return false;
 else if(left && !right) return false;
 else if(!left && !right) return true;
 else if(left->val != right->val) return false;
 else
 {
 bool outside = Compare(left->left, right->right);
 bool inside = Compare(left->right, right->left);
 return outside && inside;
 }
 }
 bool isSymmetric(TreeNode* root)
 {
 return Compare(root->left, root->right);
 }

第一百零四题：二叉树的最大深度

求深度：用前序遍历；求高度：用后序遍历

Mon, 01 Jan 0001 00:00:00 +0000

第四十九题：字母异位词分组

实现思路：记录每个字符串中单个字母的出现频率，并以字符串形式存储起来（如”0110200000….")，可以提前将字符串的空间预留26位（对应26个字母），然后将这个字符串作为哈希表的key，用来查找表中存储着异位词的vector值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


vector<vector<string>> groupAnagrams(vector<string>& strs)
{
 std::vector<vector<string>> res;
 std::unordered_map<string, std::vector<string>> um_pair;
 for(auto& str : strs)
 {
 string count(26, 0);
 for(auto& c : str)
 {
 count[c - 'a'] += 1;
 }
 um_pair[count].push_back(str);
 }
 for(auto& pair : um_pair)
 {
 res.push_back(pair.second);
 }
 return res;
}

第一百二十八题：最长连续序列

使用到了unordered_set，它只存储key，逻辑意义是“这个元素是否存在于集合中？”

具体思路：对于一个元素，首先判断他的上一个元素（当前值减去1）是否在集合中，

- 如果在，就意味着当前元素不是起始位置，不需要管他，直接进行下一次循环；
- 如果不在，代表着当前元素是起始位置，然后从他开始向后遍历，直到下一个元素不存在于集合中，此时得到的长度即为连续序列的长度

每一层循环都对res进行一次比较，如果当前长度更大，就替换之前的res

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


int longestConsecutive(vector<int>& nums)
{
 int res = 0;
 std::unordered_set<int> seqs(nums.begin(), nums.end());
 for(auto num : seqs)
 {
 int temp = 1;
 if(seqs.contains(num - 1))
 continue;
 while(seqs.contains(num + 1))
 {
 temp++;
 num++;
 }
 res = std::max(temp, res);
 }
 return res;
}

Mon, 01 Jan 0001 00:00:00 +0000

第二十一题：合并两个有序链表

使用的是递归的方法

首先判断是否有链表为空，如果是，则直接返回另一个链表

之后对list1和list2的值进行判断，更小者的下一个节点将调用原函数继续递归（比如情况一，list1的值更小，就让list1的next节点继续调用函数，将list1剩下的节点继续与list2比较）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


ListNode* mergeTwoLists(ListNode* list1, ListNode* list2)
 {
 if(list1 == nullptr) return list2;
 if(list2 == nullptr) return list1;
 if(list1->val < list2->val)
 {
 list1->next = mergeTwoLists(list1->next, list2);
 return list1;
 }
 else
 {
 list2->next = mergeTwoLists(list1, list2->next);
 return list2;
 }
 }

第一百一十四题：环形链表

使用的是双指针（快慢指针）

如果链表中此存在环的话，那么两个指针就一定会在这个环内循环，也就一定会相遇，因此可以将两个指针相等作为链表中存在环的判断条件（至于为什么会相遇：这里令慢指针的速度为1，快指针速度为2，两者的相对速度为1，所以在进入环之后，相当于是快指针在以1的速度追慢指针，之后一定会追上）

注：这里的两个if一定要先判断head与fast是否为空！！！！！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


bool hasCycle(ListNode *head)
 {
 if(head == nullptr || head->next == nullptr) return false;
 ListNode *slow = head, *fast = head->next;
 while(slow != fast)
 {
 if( fast == nullptr || fast->next == nullptr) return false;
 slow = slow->next;
 fast = fast->next->next;
 }
 return true;
 }

第一百六十题：相交链表

设节点指针A，B分别指向两个链表的头节点，C为首个公共节点

Mon, 01 Jan 0001 00:00:00 +0000

第二题：两数相加

首先明确思路，逐节点的将l1和l2相加，如果遇到需要进位的情况，就单独将所进的位数保存起来，并加到下一次的sum中去，然后在同一次循环中构造好相加后的链表

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


ListNode* addTwoNumbers(ListNode* l1, ListNode* l2)
{
 ListNode dummy(0);
 ListNode* curr = &dummy;

 int carry = 0;
 while(l1 || l2 || carry != 0)
 {
 int sum = carry;
 if(l1)
 {
 sum += l1->val;
 l1 = l1->next;
 }
 if(l2)
 {
 sum += l2->val;
 l2 = l2->next;
 }

 // 进位
 carry = sum / 10;
 int digit = sum % 10;
 curr->next = new ListNode(digit);
 curr = curr->next;
 }
 return dummy.next;
}

第十九题：删除链表的倒数第 N 个结点

使用的是双指针

155、394、739

Mon, 01 Jan 0001 00:00:00 +0000

第一百五十五题：最小栈

对这个类需要完成的任务有五个：

1.初始化 2.入栈 3.出栈 4.获取栈顶元素 5.获取最小值

因为初始的时候没有元素需要初始化，所以这个类的构造函数不需要去管他

通过在这个类中构建一个STL自带的stack，就可以实现234的操作，而5则需要再使用一个辅助栈，这题的难点也是在5

题目要求在常数时间内检索到最小值，所以一个一个去遍历肯定是不行的，这也是引入辅助栈的原因，我们可以通过不断地将更小的元素压入这个辅助栈（minst），来达到”栈顶的元素肯定是最小“的条件；之后如果需要取出最小元素的话，只需要对minst进行一次出栈操作即可

具体实现：

1.当有元素传入时，如果此时minst为空，就直接入栈，此后入栈的元素都是当前栈顶元素与传入元素的更小值

2.出栈操作也应该是两者同时进行的，因为最小值需要根据st的元素动态更新（假如此时st的栈顶就是最小元素，而下一步操作就是出栈，那么之后栈中的最小元素也应该发生变化）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


class MinStack
{
public:
 std::stack<int> minst;
 std::stack<int> st;

 MinStack()
 {
 }

 void push(int val)
 {
 st.push(val);
 if(minst.empty()) minst.push(val);
 else minst.push(std::min(val, minst.top()));
 }

 void pop()
 {
 minst.pop();
 st.pop();
 }

 int top()
 {
 return st.top();
 }

 int getMin()
 {
 return minst.top();
 }
};

第三百九十四题：字符串解码

使用到的是栈和递归

20

Mon, 01 Jan 0001 00:00:00 +0000

第二十题：有效的括号

使用到的知识点是栈

利用栈的FILO的特性，可以很好的对相应的括号进行匹配

比如"{ [ ( ) ] } "

第一次先压入{，接着判断下一个括号的类型，如果为左括号，则继续压入；如果为相匹配的右括号，则弹出；如果为不匹配的右括号，则直接返回false

最后如果整个栈都为空，就意味着所有的括号都得到了匹配，那么就返回true

注意：在一开始的时候，要判断一下特殊情况——

元素个数为奇数，就意味着总会有一个括号无法被匹配，直接返回false

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


bool isValid(string s)
 {
 std::vector<char> stack;
 if(s.size() % 2 == 1) return false;
 for(int n = 0; n < s.size(); n++)
 {
 if(s[n] == '(' || s[n] == '[' || s[n] == '{') stack.push_back(s[n]);
 else
 {
 if (stack.empty()) return false;
 if(s[n] == ')' && stack.back() == '(') stack.pop_back();
 else if(s[n] == ']' && stack.back() == '[') stack.pop_back();
 else if(s[n] == '}' && stack.back() == '{') stack.pop_back();
 else return false;
 }
 }
 if(stack.empty()) return true;
 return false;
 }