大学实训踩坑后我换了这个c语言在线测试平台刷题200道直通大厂面试

说实话，大二那会儿我差点就要放弃计算机了。

不是因为课程太难，而是实训课那套”本地跑通就完事”的做题方式，彻底把我搞崩溃了。老师让我们手写一个链表实现，我憋了三个晚上，本地测试全过，提交到oj系统，直接WA（Wrong Answer）。问了一圈同学，人家一个晚上就AC了。后来才知道，是我没有处理边界情况——空链表、单节点链表、头节点删除这些极端场景，我连想都没想。

从那以后我就悟了：代码能跑，不等于代码写对。

为什么传统刷题方式会踩坑

咱们先把话说清楚，不是大家不努力，而是方法真的有问题。

我以前是这么刷题的：在本地IDE里写代码，写完自己造几个测试用例，看着输出对了就心满意足，接着看下一题。听起来挺合理对吧？但问题就出在这里。

举个例子，有一道经典的”两数之和”题目，我当时是这么写的：

#include <stdio.h>
#include <stdlib.h>

int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if (nums[i] + nums[j] == target) {
                int* result = (int*)malloc(2 * sizeof(int));
                result[0] = i;
                result[1] = j;
                *returnSize = 2;
                return result;
            }
        }
    }
    *returnSize = 0;
    return NULL;
}

本地测试用 [2,7,11,15] target=9 跑，完美输出 0 1。我得意洋洋地过了下一题。直到后来面试被问到这道题，我连”空间复杂度”和”时间复杂度”都说不利索，面试官随口一问：”如果数组特别大，你这种O(n²)的做法能过吗？”我当场就懵了。

所以真正的问题是什么？

第一，没有评测系统实时验证，你以为对了其实错了。 很多边界条件自己根本想不到，比如空输入、负数、溢出、单元素情况。这些在oj系统里是标配测试用例，你自己造根本造不全。

第二，没有性能反馈。 本地跑个几百个数据，肉眼看着挺快，但数据量上来就超时。oj系统会给你精确的时间消耗和内存占用，逼着你优化算法。

第三，没有系统性的题目规划。 今天刷一道链表，明天刷一道字符串，东一榔头西一棒槌，到了面试发现连一个数据结构都没吃透。

我最终选定的这个平台到底好在哪

折腾了一圈，我最后锁定了一个在线刷题平台，用它刷了200道c语言题目，后面面试基本没掉链子。这个平台有几个地方是真香。

1. 题目分类极其科学，不瞎刷

它把题目按知识点和难度分了维度，比如”数组”下面还有”双指针”“滑动窗口”“前缀和”这些子分类。我从最基础的开始，把”数组”这个板块从头到尾刷了一遍，每种题型都搞懂套路，而不是随机挑题做。

比如滑动窗口这块，平台给了三道经典题：

第一题：最长无重复字符的子串

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
using namespace std;

int lengthOfLongestSubstring(char* s) {
    int n = strlen(s);
    if (n == 0) return 0;
    
    // 用一个数组记录字符上次出现的位置
    // 这里假设字符是ASCII字符
    int lastPos[256];
    memset(lastPos, -1, sizeof(lastPos));
    
    int maxLen = 0;
    int left = 0;
    
    for (int right = 0; right < n; right++) {
        // 如果当前字符已经在窗口内出现过
        if (lastPos[(unsigned char)s[right]] >= left) {
            // 收缩左边界
            left = lastPos[(unsigned char)s[right]] + 1;
        }
        // 更新最大长度
        maxLen = max(maxLen, right - left + 1);
        // 记录当前字符的位置
        lastPos[(unsigned char)s[right]] = right;
    }
    
    return maxLen;
}

int main() {
    char s1[] = "abcabcbb";
    char s2[] = "bbbbb";
    char s3[] = "pwwkew";
    
    printf("最长无重复子串长度: %d\n", lengthOfLongestSubstring(s1));  // 输出3
    printf("最长无重复子串长度: %d\n", lengthOfLongestSubstring(s2));  // 输出1
    printf("最长无重复子串长度: %d\n", lengthOfLongestSubstring(s3));  // 输出3
    
    return 0;
}

这道题看似简单，但滑动窗口的核心思想——”左右指针配合哈希表记录状态”——理解了之后，后面类似的题就一通百通了。平台在这里还会给出”提示”，当你卡住的时候点一下，它会告诉你思路而不是直接给答案，这个设计特别聪明。

第二题：无重复字符的最长字串

这道题和上面那道是兄弟题，平台会提示你把这道题和上一道对比着做，体会相似题目的不同变体。这种题目之间的关联引导，比你自己瞎刷高效太多了。

第三题：最小覆盖子串

这道题是滑动窗口的进阶版，难度上升了一个台阶，但平台有完整的题解和”思考过程”展示，不是直接扔答案。它会告诉你：”这道题的难点在于如何判断当前窗口是否合法，以及如何在合法窗口中找最小值。”

2. 评测系统特别严格，逼你写对

这个平台oj系统测试用例覆盖非常全。我印象最深的一道题是”反转链表”，我一开始写的代码在本地用5个节点的链表测试完全正确，提交上去直接部分超时。后来发现是我的递归写法在链表特别长的情况下会栈溢出。

// 错误的递归写法（会栈溢出）
struct ListNode* reverseList(struct ListNode* head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    struct ListNode* newHead = reverseList(head->next);
    head->next->next = head;
    head->next = NULL;
    return newHead;
}

// 正确的迭代写法
struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode* prev = NULL;
    struct ListNode* curr = head;
    
    while (curr != NULL) {
        struct ListNode* nextTemp = curr->next;
        curr->next = prev;
        prev = curr;
        curr = nextTemp;
    }
    
    return prev;
}

oj系统会给你每个测试用例的执行时间和内存消耗，我一看自己的递归版本，内存占用直接比迭代版本高了好几倍，这才意识到问题。这种实时反馈，比你自己闷头写代码强太多了。

3. 题目难度梯度设计合理

很多人刷题挫败感强，就是因为一开始就挑难题。这个平台有明确的难度标识，我从”简单”级别的100道题开始刷，每道题都搞懂背后的思路，然后再慢慢往上爬。

比如”单链表的基本操作”这个板块，题目难度是这样排的：

• 第1题：判断链表是否为空（难度★）
• 第2题：遍历并打印链表（难度★）
• 第3题：计算链表长度（难度★）
• 第4题：在链表尾部插入节点（难度★★）
• 第5题：在链表头部插入节点（难度★★）
• 第6题：删除指定位置的节点（难度★★）
• 第7题：反转链表（难度★★）
• 第8题：找链表的中间节点（难度★★）
• 第9题：判断链表是否有环（难度★★★）
• 第10题：找环的入口节点（难度★★★）

每一道题都是前面知识的积累，不会因为突然跳难度而卡住。我在这个板块刷了10道题，把链表的所有基本操作全都吃透了，后面面试遇到链表题基本上都是一看就会。

4. 有社区和题解，但不是直接抄答案

平台上每个题目下面都有讨论区，很多人会分享自己的思路和代码。有意思的是，直接看题解会被提示”请先独立思考后再查看”，你只有提交了至少一次错误的答案，才能解锁详细题解。这个设计逼着你先自己动脑子，而不是当伸手党。

我记得有一道题叫”杨辉三角”，我一开始用的是二维数组，空间复杂度是O(n²)，想了半天不知道怎么优化。后来在讨论区看到有人用一维数组实现，瞬间就明白了——每次只保留上一行的数据，从左到右覆盖更新。这种启发式的学习，比自己硬憋两天强多了。

#include <stdio.h>
#include <stdlib.h>

int** generate(int numRows, int* returnSize, int** returnColumnSizes) {
    *returnSize = numRows;
    *returnColumnSizes = (int*)malloc(numRows * sizeof(int));
    
    int** result = (int**)malloc(numRows * sizeof(int*));
    
    for (int i = 0; i < numRows; i++) {
        (*returnColumnSizes)[i] = i + 1;
        result[i] = (int*)malloc((i + 1) * sizeof(int));
        result[i][0] = 1;  // 每行第一个元素是1
        result[i][i] = 1;  // 每行最后一个元素是1
        
        // 中间的每个元素等于上一行对应位置的两个元素之和
        for (int j = 1; j < i; j++) {
            result[i][j] = result[i-1][j-1] + result[i-1][j];
        }
    }
    
    return result;
}

void printTriangle(int** triangle, int numRows) {
    for (int i = 0; i < numRows; i++) {
        for (int j = 0; j <= i; j++) {
            printf("%d ", triangle[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int numRows = 5;
    int returnSize;
    int* returnColumnSizes;
    
    int** triangle = generate(numRows, &returnSize, &returnColumnSizes);
    printTriangle(triangle, numRows);
    
    // 释放内存
    for (int i = 0; i < numRows; i++) {
        free(triangle[i]);
    }
    free(triangle);
    free(returnColumnSizes);
    
    return 0;
}

200道题具体怎么刷，我的时间线

我用了大概三个月，每天花两个小时刷这道题，周末会多一些。整个节奏是这样的：

第一个月：基础数据结构专项突破

这段时间我把数组、链表、栈、队列这四个板块全部过了一遍。每个板块从最简单题开始，把基本操作写得滚瓜烂熟。

比如栈和队列这一块，平台有6道题：

// 用数组实现一个栈
typedef struct {
    int* data;
    int top;
    int capacity;
} MyStack;

MyStack* stackCreate(int capacity) {
    MyStack* stack = (MyStack*)malloc(sizeof(MyStack));
    stack->data = (int*)malloc(capacity * sizeof(int));
    stack->top = -1;
    stack->capacity = capacity;
    return stack;
}

void stackPush(MyStack* stack, int value) {
    if (stack->top < stack->capacity - 1) {
        stack->data[++stack->top] = value;
    }
}

int stackPop(MyStack* stack) {
    if (stack->top >= 0) {
        return stack->data[stack->top--];
    }
    return -1;  // 栈空
}

int stackTop(MyStack* stack) {
    if (stack->top >= 0) {
        return stack->data[stack->top];
    }
    return -1;
}

int stackIsEmpty(MyStack* stack) {
    return stack->top == -1;
}

这道题看起来简单，但很多细节要注意，比如栈满的判断、栈空的判断、内存管理。oj系统会测试各种极端情况，逼着你把代码写得严谨。

第二个月：算法思想专项突破

第二阶段我重点攻克了递归、分治、动态规划、贪心、回溯这些算法思想。这个阶段题目难度明显上来了，但我之前打的基础让我能跟上节奏。

比如动态规划这块，第一道入门题是”爬楼梯”：

#include <stdio.h>
#include <stdlib.h>

int climbStairs(int n) {
    if (n <= 2) {
        return n;
    }
    
    // 用滚动数组优化空间
    int prev2 = 1;  // f(0)
    int prev1 = 2;  // f(1)
    int current;
    
    for (int i = 2; i < n; i++) {
        current = prev1 + prev2;
        prev2 = prev1;
        prev1 = current;
    }
    
    return prev1;
}

int main() {
    printf("爬3层楼梯的方法数: %d\n", climbStairs(3));   // 输出3
    printf("爬4层楼梯的方法数: %d\n", climbStairs(4));   // 输出5
    printf("爬5层楼梯的方法数: %d\n", climbStairs(5));   // 输出8
    
    return 0;
}

这道题就是经典的斐波那契数列变种，重点是要理解”状态转移方程”——到第n阶的方法数等于到第n-1阶和第n-2阶的方法数之和。理解了这一点，后面所有动态规划的题就都有一个思考框架了。

后面还刷了”0-1背包”“最长公共子序列”“编辑距离”这些经典dp题，每道题都反复琢磨状态定义和转移方程，慢慢就建立起了解题的直觉。

第三个月：综合冲刺和面试模拟

最后一个月，我开始做综合性的题目，模拟面试环境限时做题。平台有”面试模式”，会随机抽题给你，限时15-30分钟，逼你在压力下思考和写代码。

这个阶段我遇到了不少坑，比如有一道”合并两个有序链表”的题，我在压力下写错了边界条件，导致无限循环。oj系统显示”运行超时”，我排查了二十分钟才发现是某个指针没有正确更新。这种在压力下犯错然后纠正的经历，比在放松状态下做对一百道题都有价值。

面试时这些题真的用上了

说实话，刷完200道题之后去面试，那种感觉有点像以前考试前刷题刷够了，考场上遇到熟悉题型的那种从容。

我面的一家大厂，第二面是算法题，题目是”判断二叉树是否对称”。我一看，这不就是递归的经典应用吗？当场就把代码写出来了：

#include <stdio.h>
#include <stdlib.h>

typedef struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

int isSymmetricHelper(TreeNode* left, TreeNode* right) {
    // 两个节点都为空，对称
    if (left == NULL && right == NULL) {
        return 1;
    }
    // 只有一个为空，不对称
    if (left == NULL || right == NULL) {
        return 0;
    }
    // 值不相等，不对称
    if (left->val != right->val) {
        return 0;
    }
    // 递归检查：左子树的左子树和右子树的右子树对称
    //        且左子树的右子树和右子树的左子树对称
    return isSymmetricHelper(left->left, right->right) &&
           isSymmetricHelper(left->right, right->left);
}

int isSymmetric(TreeNode* root) {
    if (root == NULL) {
        return 1;
    }
    return isSymmetricHelper(root->left, root->right);
}

面试官看我写得又快又对，又问了我几个边界情况和优化方向，我都能接上。最后面试官说：”你这个解题思路挺清晰的，递归的终止条件和递推关系都考虑到了，不错。”

其实哪有什么天赋，就是之前刷题的时候，每道题都反复琢磨过这些点。

给想刷c语言题的同学几点真心建议

最后说几句掏心窝子的话。

第一，别贪多，要把每道题吃透。 200道题不是说刷完就完事了，每道题至少要自己独立写出正确代码，并且能手头讲清楚思路。如果一道题看了题解才会，那不算你会。

第二，错题本要定期回顾。 平台可以标记错题，我每隔一周就会把做错的题重新刷一遍。很多题当时做对了，过段时间再回头看还是卡住，这就是没真正理解的标志。重新做一遍，把当时卡住的地方搞明白，才是真正的进步。

第三，别怕写不出来，先写暴力解法。 面试时经常遇到完全没思路的题，这时候别慌，先写一个暴力解法，保证能跑对，然后再想优化。很多时候，暴力解法和优化解法之间的差距，就是一个思路的转换。平台上的题目很多都有”进阶挑战”，先拿基础分，再冲满分。

第四，把c语言的基础语法再巩固一下。 刷了200道题之后，我发现c语言里有些细节真的很容易坑人。比如指针操作、内存管理、结构体对齐这些，平时不注意，到oj系统里一提交就报错。所以我后来专门花时间把c语言的这些细节过了一遍，做题的时候顺手就对了，不用再花时间debug。

比如内存管理这块，很多人写代码从来不释放内存，本地跑没问题，oj系统测多了就会内存超限：

// 错误写法：内存泄漏
char* createString(int len) {
    char* str = (char*)malloc((len + 1) * sizeof(char));
    // 忘记初始化，而且调用方不知道要释放
    return str;
}

// 正确写法：明确所有权，调用方负责释放
char* createString(int len) {
    char* str = (char*)malloc((len + 1) * sizeof(char));
    if (str == NULL) {
        return NULL;  // 内存分配失败
    }
    str[0] = '\0';  // 初始化为空字符串
    return str;
}

void freeString(char** str) {
    if (str != NULL && *str != NULL) {
        free(*str);
        *str = NULL;  // 释放后置空，防止野指针
    }
}

这种细节看似小事，但在oj系统和面试中都是高频考点。

---

说了这么多，核心就一句话：找对平台，用对方法，坚持下来，c语言的算法题真的没有那么难。 我之前踩过的坑，希望你们能绕开。200道题刷完，面试官问什么你基本都能接得住，那种自信是实打实练出来的，不是吹出来的。

加油吧，未来的工程师们。