要高效刷完 **LeetCode Hot 100**（
力扣热门100题），并能在面试中灵活应对，必须掌握一套核心的算法与
数据结构知识体系。Hot 100 的题目覆盖了大多数大厂面试常考类型，以下是你**必须掌握的知识点、对应的
数据结构/算法思想、典型题目示例和解题模板代码**。
---
## ✅ 一、必备基础知识总览
| 类别 | 核心知识点 |
|
------|
-----------|
|
数据结构 | 数组、字符串、链表、栈、队列、哈希表、堆（优先队列）、树、图、并查集、前缀树（Trie） |
| 算法思想 | 双指针、滑动窗口、递归、回溯、分治、贪心、动态规划（DP）、二分查找、BFS、DFS、拓扑排序 |
| 技巧 | 哈希映射加速查找、哨兵技巧、状态机、区间合并、逆向思维 |
---
## ✅ 二、按类别详解 + 典型题目 + C++ 模板代码
### 1. **数组 & 双指针**
#### 常见题型：
- 两数之和（哈希优化）
- 三数之和（排序+双指针）
- 移动零、删除有序数组重复项（快慢指针）
#### 示例：两数之和
```cpp
#include <vector>
#include <unordered_map>
using namespace std;
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> map;
for (int i = 0; i < nums.size(); ++i) {
int complement = target
- nums[i];
if (map.count(complement)) {
return {map[complement], i};
}
map[nums[i]] = i;
}
return {};
}
```
---
### 2. **滑动窗口**
#### 常见题型：
- 最小覆盖子串（Hard）
- 字符串的排列（Medium）
- 无重复字符的最长子串（Medium）
#### 模板代码（通用滑动窗口）
```cpp
string minWindow(string s, string t) {
unordered_map<char, int> need, window;
for (char c : t) need[c]++;
int left = 0, right = 0;
int valid = 0;
int start = 0, len = INT_MAX;
while (right < s.size()) {
char c = s[right++];
if (need.count(c)) {
window[c]++;
if (window[c] == need[c])
valid++;
}
while (valid == need.size()) {
if (right
- left < len) {
start = left;
len = right
- left;
}
char d = s[left++];
if (need.count(d)) {
if (window[d] == need[d])
valid
--;
window[d]
--;
}
}
}
return len == INT_MAX ? "" : s.substr(start, len);
}
```
---
### 3. **链表**
#### 常见题型：
- 反转链表（迭代/递归）
- 环形链表 II（找入口）
- 合并两个有序链表
- K 个一组反转链表（Hard）
#### 示例：反转链表（迭代）
```cpp
struct ListNode {
int val;
ListNode *next;
ListNode() : val(0), next(nullptr) {}
ListNode(int x) : val(x), next(nullptr) {}
};
ListNode* reverseList(ListNode* head) {
ListNode* prev = nullptr;
ListNode* curr = head;
while (curr) {
ListNode* next = curr
->next;
curr
->next = prev;
prev = curr;
curr = next;
}
return prev;
}
```
---
### 4. **栈与队列**
#### 常见题型：
- 有效的括号（栈匹配）
- 每日温度（单调栈）
- 接雨水（Hard，双栈或双指针）
- 用栈实现队列（设计题）
#### 示例：单调栈（
每日温度）
```cpp
vector<int> dailyTemperatures(vector<int>& temperatures) {
int n = temperatures.size();
vector<int> res(n, 0);
stack<int> st; // 存储下标
for (int i = 0; i < n; ++i) {
while (!st.empty() && temperatures[i] > temperatures[st.top()]) {
int idx = st.top(); st.pop();
res[idx] = i
- idx;
}
st.push(i);
}
return res;
}
```
---
### 5. **二叉树 & DFS/BFS**
#### 常见题型：
- 二叉树的最大深度（BFS/DFS）
- 验证二叉搜索树（中序遍历）
- 二叉树的最近公共祖先（LCA）
- 层序遍历（BFS）
#### 示例：层序遍历（BFS）
```cpp
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode() : val(0), left(nullptr), right(nullptr) {}
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> res;
if (!root) return res;
queue<TreeNode*> q;
q.push(root);
while (!q.empty()) {
int size = q.size();
vector<int> level;
for (int i = 0; i < size; ++i) {
TreeNode* node = q.front(); q.pop();
level.push_back(node
->val);
if (node
->left) q.push(node
->left);
if (node
->right) q.push(node
->right);
}
res.push_back(level);
}
return res;
}
```
---
### 6. **回溯算法（Backtracking）**
#### 常见题型：
- 子集、组合、全排列
- N 皇后（Hard）
- 复原 IP 地址
#### 示例：全排列
```cpp
vector<vector<int>> permute(vector<int>& nums) {
vector<vector<int>> res;
vector<int> path;
vector<bool> used(nums.size(), false);
function<void()> backtrack = [&]() {
if (path.size() == nums.size()) {
res.push_back(path);
return;
}
for (int i = 0; i < nums.size(); ++i) {
if (used[i]) continue;
used[i] = true;
path.push_back(nums[i]);
backtrack();
path.pop_back();
used[i] = false;
}
};
backtrack();
return res;
}
```
---
### 7. **动态规划（Dynamic Programming）**
#### 常见题型：
- 爬楼梯（斐波那契）
- 打家劫舍 I/II
- 最长递增子序列（LIS）
- 编辑距离（Hard）
- 背包问题变种
#### 示例：最长递增子序列（LIS）
```cpp
int lengthOfLIS(vector<int>& nums) {
if (nums.empty()) return 0;
vector<int> dp(nums.size(), 1);
int maxLen = 1;
for (int i = 1; i < nums.size(); ++i) {
for (int j = 0; j < i; ++j) {
if (nums[j] < nums[i]) {
dp[i] = max(dp[i], dp[j] + 1);
}
}
maxLen = max(maxLen, dp[i]);
}
return maxLen;
}
```
> ⚠️ 进阶可用 `lower_bound` 实现 O(n log n) 解法。
---
### 8. **二分查找**
#### 常见题型：
- 搜索旋转排序数组（Medium）
- 寻找峰值（Medium）
- 在排序数组中查找元素的第一个和最后一个位置
#### 示例：标准二分查找（左边界）
```cpp
int searchLeftBound(vector<int>& nums, int target) {
int left = 0, right = nums.size();
while (left < right) {
int mid = left + (right
- left) / 2;
if (nums[mid] < target)
left = mid + 1;
else
right = mid;
}
return left < nums.size() && nums[left] == target ? left :
-1;
}
```
---
### 9. **并查集（Union
-Find）**
#### 常见题型：
- 岛屿数量（也可用DFS）
- 朋友圈（省份数量）
- 冗余连接
#### 并查集模板
```cpp
class UnionFind {
public:
vector<int> parent;
int count;
UnionFind(int n) : count(n) {
parent.resize(n);
for (int i = 0; i < n; ++i) parent[i] = i;
}
int find(int x) {
if (parent[x] != x)
parent[x] = find(parent[x]); // 路径压缩
return parent[x];
}
void unite(int x, int y) {
int rx = find(x), ry = find(y);
if (rx != ry) {
parent[rx] = ry;
--count;
}
}
};
```
---
### 10. **堆（优先队列）**
#### 常见题型：
- 数组中的第K个最大元素
- 前K个高频元素
- 合并K个升序链表
#### 示例：前K个高频元素
```cpp
vector<int> topKFrequent(vector<int>& nums, int k) {
unordered_map<int, int> freq;
for (int n : nums) freq[n]++;
auto cmp = [](const pair<int,int>& a, const pair<int,int>& b) {
return a.second < b.second; // 大顶堆
};
priority_queue<pair<int,int>, vector<pair<int,int>>, decltype(cmp)> pq(cmp);
for (auto& p : freq) {
pq.push(p);
}
vector<int> res;
for (int i = 0; i < k; ++i) {
res.push_back(pq.top().first); pq.pop();
}
return res;
}
```
---
## ✅ 三、学习建议
| 步骤 | 建议 |
|
------|
------|
| 第一步 | 掌握每类题型的**模板代码**和**通用思路** |
| 第二步 | 按分类刷题（数组 → 链表 → 树 → 回溯 → DP） |
| 第三步 | 总结变体题，比如“两数之和”有多种变形 |
| 第四步 | 练习手写代码，避免依赖 IDE 自动补全 |
| 第五步 | 模拟面试：限时答题 + 口述思路 |
---
本文解析了如何使用C语言解决LeetCode中的数据结构问题217，介绍了暴力解法和利用qsort进行排序并检测重复的方法。重点在于提升算法效率，避免时间复杂度过高。
扫一扫
75
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
