LeetCode刷题指南：从C语言基础到算法进阶

1. 从零开始的LeetCode救赎之路

作为一名计算机专业大四学生，我完全理解这种"技术焦虑"——看着同学们纷纷拿到offer或开始创业，自己却连基础算法题都磕磕绊绊。但我要告诉你个秘密：90%的"大神"也都是从"两数之和"这种题目开始刷起的。去年这时候的我，连二叉树遍历都要查文档，现在也能轻松解决中等难度题目了。关键不在于起点高低，而在于是否掌握正确的练习方法。

LeetCode本质上是个"算法健身房"，它的价值不仅在于面试通关，更在于培养计算思维。我建议从C语言开始刷题，虽然它没有现成的数据结构库，但正因如此能让你真正理解内存管理和指针操作——这是区分"API调用工程师"和"真正程序员"的关键门槛。当你能用C实现哈希表时，用其他语言简直就是降维打击。

2. C语言刷题实战指南

2.1 开发环境配置

工欲善其事必先利其器，推荐使用VSCode + C/C++插件组合。配置要点：

1. 安装MinGW-w64作为编译器（注意勾选posix线程和seh异常处理）
2. 在.vscode/tasks.json中配置build任务，关键参数：

json复制"args": [
    "-fdiagnostics-color=always",
    "-g",
    "${file}",
    "-o",
    "${fileDirname}\\${fileBasenameNoExtension}.exe",
    "--std=c11", // 使用C11标准
    "-Wall",     // 开启所有警告
    "-Wextra"    // 额外警告
]

3. 安装C/C++ Test Runner插件便于运行测试用例

避坑提示：避免使用Dev-C++等老旧IDE，它们对现代C标准支持不足。初学者常犯的错误是忘记在代码末尾释放malloc的内存，建议安装valgrind进行内存检查。

2.2 基础数据结构实现

LeetCode的C语言解法需要自建数据结构，这是最好的学习机会：

动态数组实现要点：

c复制typedef struct {
    int *data;
    int size;
    int capacity;
} Vector;

void push_back(Vector *vec, int val) {
    if (vec->size >= vec->capacity) {
        vec->capacity = vec->capacity ? vec->capacity * 2 : 1;
        vec->data = realloc(vec->data, vec->capacity * sizeof(int));
    }
    vec->data[vec->size++] = val;
}

链表常见陷阱：

• 虚拟头节点(dummy node)能简化边界条件处理
• 修改链表指针时要注意操作顺序，比如反转链表时：

c复制struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode *prev = NULL;
    while (head) {
        struct ListNode *next = head->next; // 必须先保存next
        head->next = prev;
        prev = head;
        head = next;
    }
    return prev;
}

2.3 算法模板精讲

二分查找的通用写法：

c复制int binarySearch(int* nums, int numsSize, int target) {
    int left = 0, right = numsSize; // 注意右边界开区间
    while (left < right) {
        int mid = left + (right - left) / 2; // 防溢出
        if (nums[mid] < target) {
            left = mid + 1;
        } else {
            right = mid; // 保持右边界开区间
        }
    }
    return left; // 返回插入位置
}

快速排序的经典实现：

c复制void swap(int *a, int *b) {
    int tmp = *a; *a = *b; *b = tmp;
}

int partition(int *nums, int left, int right) {
    int pivot = nums[right];
    int i = left;
    for (int j = left; j < right; j++) {
        if (nums[j] < pivot) {
            swap(&nums[i++], &nums[j]);
        }
    }
    swap(&nums[i], &nums[right]);
    return i;
}

void quickSort(int *nums, int left, int right) {
    if (left >= right) return;
    int p = partition(nums, left, right);
    quickSort(nums, left, p - 1);
    quickSort(nums, p + 1, right);
}

3. 刷题进阶方法论

3.1 题目分类训练法

我总结的C语言刷题路线图：

1. 第一阶段（2周）：

   • 数组：27.移除元素、88.合并有序数组
   • 字符串：344.反转字符串、541.反转字符串II
   • 链表：203.移除链表元素、206.反转链表

2. 第二阶段（3周）：

   • 双指针：15.三数之和、18.四数之和
   • 滑动窗口：209.长度最小的子数组、904.水果成篮
   • 二叉树：递归三序遍历（144/94/145）

3. 第三阶段（持续）：

   • 回溯：46.全排列、78.子集
   • 动态规划：70.爬楼梯、198.打家劫舍
   • 贪心：455.分发饼干、376.摆动序列

3.2 调试技巧大全

C语言刷题特有的调试策略：

1. 内存检测：在提交前添加以下代码检查内存泄漏

c复制#ifdef DEBUG
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#define malloc(size) _malloc_dbg(size, _NORMAL_BLOCK, __FILE__, __LINE__)
#endif

// 程序结束时调用
_CrtDumpMemoryLeaks();

2. 可视化调试：

c复制void printArray(int *arr, int size) {
    printf("[");
    for (int i = 0; i < size; i++) {
        printf("%d%s", arr[i], i < size - 1 ? "," : "");
    }
    printf("]\n");
}

// 二叉树中序打印
void inorder(struct TreeNode* root) {
    if (!root) return;
    inorder(root->left);
    printf("%d ", root->val);
    inorder(root->right);
}

4. 从刷题到博客的技术输出

4.1 解题笔记规范

我实践的博客写作模板：

markdown复制## 题目描述
[原题链接](https://leetcode.com/problems/...)

## 初始思路
- 暴力解法的时间复杂度分析
- 遇到的边界条件问题

## 优化过程
1. 第一版代码的问题（示例）
```c
// 原始低效代码

2. 发现的性能瓶颈（通过leetcode执行用时分析）

3. 最终方案

c复制// 优化后的代码

复杂度分析

• 时间复杂度：数学推导过程
• 空间复杂度：内存使用情况

同类题目

• 相关题目1
• 相关题目2

code复制
### 4.2 技术博客的持续运营

建立个人知识库的技巧：
1. 使用Obsidian管理刷题笔记，建立题目间的双向链接
2. 为每道题添加标签：#数组 #双指针 #中等难度
3. 定期将笔记整理成博客，我常用的分类：
   - 《C指针魔法：链表操作十八式》
   - 《内存视角下的动态规划》
   - 《算法竞赛中的位运算技巧》

> 经验之谈：不要追求每日一题，我实践下来最有效的是"三题循环法"——每天精做1道新题+复习2道旧题，配合周末的专题总结，这样记忆留存率能达到70%以上。

## 5. 突破技术瓶颈的实战策略

### 5.1 刻意练习四步法

我总结的高效刷题流程：
1. 严格计时15分钟独立思考
2. 无论是否解出都查看题解
3. 用C语言重写最优解法三次：
   - 第一次：边看边抄
   - 第二次：半默写状态
   - 第三次：完全独立实现
4. 制作错题卡片记录：
   - 错误类型：指针越界/内存泄漏/逻辑错误
   - 修复方法：如添加虚拟头节点
   - 预防措施：写在代码注释中的警示

### 5.2 面试手撕代码准备

大厂面试的C语言考点清单：
1. 内存管理：
   - malloc/calloc/realloc的区别
   - 结构体对齐原则（#pragma pack）
   - 内存池实现思路

2. 指针进阶：
   - 函数指针的应用场景
   - 二级指针操作链表
   - void*的泛型编程

3. 并发基础：
   - 生产者消费者模型的C实现
   - 线程安全队列的实现
   - 原子操作的应用

我常用的代码片段库：
```c
// 快速幂算法（用于动态规划优化）
long long qpow(int a, int n) {
    long long res = 1;
    while (n) {
        if (n & 1) res *= a;
        a *= a;
        n >>= 1;
    }
    return res;
}

// 并查集模板
typedef struct {
    int *parent;
    int *rank;
    int count;
} UnionFind;

UnionFind* createUF(int n) {
    UnionFind *uf = malloc(sizeof(UnionFind));
    uf->parent = malloc(n * sizeof(int));
    uf->rank = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        uf->parent[i] = i;
        uf->rank[i] = 1;
    }
    uf->count = n;
    return uf;
}

6. 技术成长的心态调整

6.1 克服冒名顶替综合征

我经历过的三个认知误区与破解方法：

1. "必须掌握所有算法才能找工作" → 实际上80%的面试题来自20%的高频考点
2. "运行时报错说明我很差" → 段错误反而是深入理解内存的好机会
3. "别人的解法更优雅" → 先用暴力解法AC，再逐步优化才是正途

6.2 建立可持续的学习节奏

我实践有效的每日计划：

• 早晨30分钟：复习昨日题目的C语言实现
• 午间1小时：专项突破（如本周专注二叉树）
• 晚间1.5小时：新题挑战+写博客总结
• 周末3小时：专题复习（把所有二叉树题目放在一起对比）

技术成长就像指针运算——重要的是找准基准地址，然后一步步偏移。我从连qsort都要查文档到现在能徒手写红黑树，最大的感悟是：在C语言的世界里，每个segfault都是通向底层理解的阶梯。当你用指针操作征服了一道Hard题目时，那种成就感比任何语言都来得强烈