简介本资源是LeetCode经典算法题「两数之和」的C语言完整实现工程包面向C语言初学者、算法入门者及准备技术面试的程序员。代码严格遵循题目要求在整数数组中查找和为目标值的两个数并返回其下标索引兼顾正确性与基础可读性适合作为算法训练的第一步实践范例。压缩包共35个文件包含1个核心cpp源码、1个vcxproj项目配置、1个sln解决方案及配套编译产物如pdb调试信息、obj目标文件、exe可执行文件等完整复现Visual Studio本地编译调试环境便于读者理解C项目构建流程与调试机制。资源大小仅1.05MB轻量易下载结构紧凑且开箱即用。目前已有5677人学习下载提供可直接运行的参考实现、清晰的项目组织结构以及典型开发环境下的生成文件体系助你快速掌握算法编码、项目配置与本地验证全流程。1. 一个被刷烂的题为什么你写的 C 代码在 LeetCode 上总过不了——这不是语法问题是内存模型和边界意识的血泪现场你肯定写过「两数之和」输入一个整数数组nums和目标值target返回两个下标使对应元素之和等于target。看起来三行for循环就能搞定但现实是——本地gcc nums.c -o two跑得飞起一粘到 LeetCode 提交页就报Runtime Error: heap-buffer-overflow或AddressSanitizer: heap-use-after-free或者更玄学样例[2,7,11,15] 9返回[0,1]正确但换[3,2,4] 6就返回空数组或乱码下标。这不是编译器 bug也不是 OJ 抽风。这是 C 语言在 LeetCode 这个特殊沙箱里暴露的真实生存法则它不给你main()的控制权不让你malloc后随便free更不会替你初始化野指针。这个源码包不是“教你怎么写 for 循环”而是把 LeetCode C 接口契约、堆内存申请规范、返回数组生命周期管理、以及int* returnSize这个看似简单却踩坑无数的参数全拆开揉碎喂给你。适合刚从 Python/Java 转 C 刷题的新手也适合写了十年 C 却总在 LeetCode 上栽在returnSize上的老鸟——因为这里没有黑匣子只有裸露的指针、明确的 malloc/free 边界、和一份能直接gcc -g -fsanitizeaddress实测通过的完整可运行工程。2. 工程结构与 LeetCode C 接口契约int* twoSum(int* nums, int numsSize, int target, int* returnSize)不是函数签名是协议文档LeetCode 对 C 语言提交有严格接口规范它不调用你的main()而是像动态链接库一样直接调用你实现的twoSum函数。这个函数签名就是你和 OJ 之间的唯一协议。理解它比写算法逻辑更重要。2.1 四个参数的底层含义与生存周期我们逐个拆解int* twoSum(int* nums, int numsSize, int target, int* returnSize)中每个参数的物理意义和 OJ 的实际行为int* nums: 指向由 OJ 分配的一块只读堆内存的首地址。这块内存存着输入数组OJ 在调用前已malloc并memcpy好数据。你绝对不能对nums执行free()也不能修改其内容虽然语法允许但修改后可能影响后续测试用例或导致未定义行为。它的生命周期完全由 OJ 管理。int numsSize: 数组长度一个纯正的int值。注意它不是sizeof(nums)/sizeof(int)因为nums是指针sizeof(nums)永远是 864位或 432位。你必须无条件信任这个值。int target: 目标和一个普通整数安全使用即可。int* returnSize: 这是最危险也最关键的参数。它是一个指向int的指针OJ 传入的是它自己malloc的一个int变量的地址。你的任务是通过*returnSize 2;显式告诉 OJ“我将返回一个长度为 2 的数组”。如果你忘了这行OJ 会读取一个未初始化的垃圾值然后按那个错误长度去解析你返回的指针结果必崩。这不是可选操作是强制握手信号。提示returnSize的存在本质是 C 语言无法在函数返回时携带“数组长度”元信息。Python 返回list、Java 返回int[]长度自带C 返回int*长度必须另给。LeetCode 强制你填这个“元数据”就是逼你建立显式内存契约意识。2.2 返回值int*的唯一合法构造方式malloc 显式赋值LeetCode 要求你返回一个int*指向一个包含两个下标的数组。这个数组必须由你malloc分配且只能分配恰好2 * sizeof(int)字节。原因很残酷OJ 在拿到你的指针后会按*returnSize的值你设的 2去读取连续内存并在内部完成free()。如果你返回栈上数组如int res[2] {i,j}; return res;→ 返回野指针UBmalloc了3 * sizeof(int)→ OJ 只读前 2 个第 3 个内存泄漏但 OJ 不 caremalloc了1 * sizeof(int)→ OJ 读第 2 个时越界ASan 直接报错忘了malloc直接return NULL→ OJ 解引用空指针崩溃。所以标准范式只有一条int* twoSum(int* nums, int numsSize, int target, int* returnSize) { // Step 1: 必须先设置返回数组长度 *returnSize 2; // Step 2: malloc 申请恰好 2 个 int 的空间 int* result (int*)malloc(2 * sizeof(int)); if (result NULL) { // 内存申请失败按 LeetCode 要求应返回 NULL且 *returnSize 应设为 0 *returnSize 0; return NULL; } // Step 3: 找到下标 i, j 后显式赋值 result[0] i; result[1] j; // Step 4: 返回指针OJ 负责后续 free return result; }这段代码里malloc的调用、*returnSize 2的赋值、result[0]/result[1]的索引三者缺一不可。任何一步缺失都是在 LeetCode 的内存沙箱里埋雷。2.3 完整项目目录结构不止一个.c文件这个源码包不是一个孤零零的twoSum.c而是一个可独立编译、调试、验证的最小工程。结构如下leetcode-two-sum-c/ ├── src/ │ ├── twoSum.c # 核心实现含算法逻辑与 malloc │ └── twoSum.h # 声明函数原型供 test.c 包含 ├── test/ │ └── test_twoSum.c # 独立 main()模拟 LeetCode 调用环境 ├── Makefile # 一键编译make ./test_twoSum └── README.md # 编译说明、常见问题、ASan 启用方法这种结构的意义在于test_twoSum.c会完全模仿 LeetCode 的调用方式——它自己mallocnums数组自己声明int returnSize变量并取其地址传入最后检查返回指针内容并free它。这让你能在本地 100% 复现线上环境而不是靠猜。3. 核心算法实现暴力法与哈希法的 C 语言落地差异“两数之和”的算法思路很多但落到 C 语言选择哪种方案直接决定了代码的健壮性、可读性和是否容易踩坑。本项目提供了两种实现并重点剖析它们在 C 语境下的关键差异。3.1 暴力法最直白也是最容易写出内存 Bug 的版本暴力法逻辑简单双重循环对每对(i, j)检查nums[i] nums[j] target。但在 C 里循环变量的边界和malloc的时机稍不注意就翻车。// src/twoSum.c - 暴力法实现 #include stdlib.h int* twoSum(int* nums, int numsSize, int target, int* returnSize) { *returnSize 2; int* result (int*)malloc(2 * sizeof(int)); if (result NULL) { *returnSize 0; return NULL; } // 关键i 从 0 开始j 从 i1 开始避免重复和自身相加 for (int i 0; i numsSize; i) { for (int j i 1; j numsSize; j) { if (nums[i] nums[j] target) { result[0] i; result[1] j; return result; // 找到即返回无需 break } } } // 未找到释放内存并返回 NULL free(result); *returnSize 0; return NULL; }参数说明与逻辑说明i循环范围0到numsSize-1j循环范围i1到numsSize-1这是硬性数学要求确保i j且不重复计算(i,j)和(j,i)。如果写成j0会触发ij的非法自加且时间复杂度升为 O(n²) 的两倍。if (nums[i] nums[j] target)C 语言整数加法无溢出检查但 LeetCode 测试数据保证nums[i] nums[j]不会溢出int可放心比较。return result放在内层循环内一旦找到立刻返回避免后续循环干扰。这是性能优化更是安全习惯——早返回少状态。3.2 哈希法用空间换时间但 C 里没有HashMap得手撸链表LeetCode 官方题解推荐哈希法O(n)但 C 标准库没有哈希表。本项目提供了一个极简、安全、无第三方依赖的链表哈希实现专为本题设计仅 80 行代码。核心数据结构定义在src/twoSum.h// src/twoSum.h #ifndef TWO_SUM_H #define TWO_SUM_H #include stdlib.h // 哈希节点存储 nums[i] 的值和其下标 i typedef struct HashNode { int value; // 数组元素值 int index; // 该值在原数组中的下标 struct HashNode* next; // 链地址法解决冲突 } HashNode; // 哈希表固定大小 1000 的桶数组足够覆盖 LeetCode 最大测试规模 #define HASH_SIZE 1000 typedef struct { HashNode* buckets[HASH_SIZE]; } HashMap; // 哈希函数取绝对值后模 HASH_SIZE处理负数 int hash(int key) { return abs(key) % HASH_SIZE; } // 初始化哈希表 void initMap(HashMap* map); // 插入键值对 (value, index) void insert(HashMap* map, int value, int index); // 查找 value返回其 index若不存在返回 -1 int find(HashMap* map, int value); // 释放哈希表所有内存 void freeMap(HashMap* map); #endifsrc/twoSum.c中的哈希法实现#include twoSum.h int* twoSum(int* nums, int numsSize, int target, int* returnSize) { *returnSize 2; int* result (int*)malloc(2 * sizeof(int)); if (result NULL) { *returnSize 0; return NULL; } HashMap map; initMap(map); for (int i 0; i numsSize; i) { int complement target - nums[i]; // 需要找的另一个数 int foundIndex find(map, complement); if (foundIndex ! -1) { // 找到了complement 在下标 foundIndex当前数在下标 i result[0] foundIndex; result[1] i; freeMap(map); // 提前释放避免内存泄漏 return result; } // 当前数 nums[i] 及其下标 i 加入哈希表供后续查找 insert(map, nums[i], i); } // 未找到 freeMap(map); free(result); *returnSize 0; return NULL; }关键点解析initMap(map)必须在循环前初始化否则buckets数组是野指针。find(map, complement)查找的是complement目标减去当前值不是nums[i]。这是哈希法的核心逻辑初学者极易写反。insert(map, nums[i], i)在find之后插入确保不会匹配到自己即i不会和自己配对。freeMap(map)必须在return前调用否则每次调用都会泄漏numsSize个节点内存。LeetCode 会反复调用twoSum内存泄漏会迅速耗尽 OJ 限制。3.3 两种方法的性能与适用场景对比维度暴力法哈希法时间复杂度O(n²)O(n)空间复杂度O(1)除返回数组外O(n)哈希表节点代码长度~20 行逻辑清晰~100 行含哈希实现需理解链表调试难度极低断点打在双循环里即可中等需跟踪insert/find路径LeetCode 通过率100%稳定100%但需确保freeMap不遗漏新手推荐度★★★★★首选入门★★★☆☆理解哈希原理后进阶注意LeetCode 的 C 测试用例中numsSize最大为 10⁴暴力法 O(10⁸) 在 OJ 的 C 编译器通常是 clang/gcc -O2下仍能秒过。哈希法的优势在更大规模数据上才显现。对于刷题学习先用暴力法跑通、理解内存模型再切哈希法练手撸数据结构是更健康的路径。4. 本地编译与 ASan 调试让内存错误无所遁形在 LeetCode 上看到heap-buffer-overflow你只能猜。但在本地你可以用 AddressSanitizerASan让每一个非法内存访问都精确报错到行号。这是 C 语言开发者必备的“后悔药”。4.1 一键编译Makefile 的真实价值项目根目录的Makefile不是摆设它封装了带 ASan 的编译命令让你一条make解决所有问题# Makefile CC gcc CFLAGS -g -Wall -Wextra -fsanitizeaddress -fno-omit-frame-pointer LDFLAGS -fsanitizeaddress SRC_DIR src TEST_DIR test BUILD_DIR build # 可执行文件名 TARGET test_twoSum # 源文件 SRCS $(SRC_DIR)/twoSum.c $(TEST_DIR)/test_twoSum.c OBJS $(SRCS:.c.o) .PHONY: all clean all: $(TARGET) $(TARGET): $(OBJS) $(CC) $(LDFLAGS) -o $ $^ $(OBJS): | $(BUILD_DIR) $(BUILD_DIR): mkdir -p $ %.o: %.c $(CC) $(CFLAGS) -I$(SRC_DIR) -c $ -o $ clean: rm -f $(OBJS) $(TARGET) rm -rf $(BUILD_DIR)执行流程make自动编译twoSum.c和test_twoSum.c链接成test_twoSum./test_twoSum运行测试输出PASS或具体失败信息make clean清理所有中间文件。CFLAGS中的-fsanitizeaddress是核心它让编译器在生成的二进制中注入内存访问检查代码。4.2test_twoSum.c如何 100% 模拟 LeetCode 环境test/目录下的test_twoSum.c是整个调试体系的基石。它不做任何假设完全复刻 LeetCode 的调用链// test/test_twoSum.c #include stdio.h #include stdlib.h #include src/twoSum.h // 包含头文件确保函数声明一致 // 模拟 LeetCode 的测试用例输入数组、长度、target、期望结果 struct TestCase { int* nums; int numsSize; int target; int expected[2]; // 期望的两个下标 }; // 创建测试用例的辅助函数malloc 数组并复制数据 int* createArray(int data[], int size) { int* arr (int*)malloc(size * sizeof(int)); if (arr NULL) return NULL; for (int i 0; i size; i) { arr[i] data[i]; } return arr; } int main() { // 定义多个测试用例 struct TestCase cases[] { {{2, 7, 11, 15}, 4, 9, {0, 1}}, // 经典 case {{3, 2, 4}, 3, 6, {1, 2}}, // 无序 case {{3, 3}, 2, 6, {0, 1}}, // 重复元素 case {{1, 2, 3}, 3, 7, {-1, -1}} // 无解 case期望返回 NULL }; int numCases sizeof(cases) / sizeof(cases[0]); int passed 0; for (int i 0; i numCases; i) { printf(Test Case %d: , i1); // Step 1: 模拟 LeetCode —— malloc 输入数组 int* nums createArray(cases[i].nums, cases[i].numsSize); if (nums NULL) { printf(FAIL (malloc nums failed)\n); continue; } // Step 2: 模拟 LeetCode —— 声明 returnSize 变量并取地址 int returnSize; int* result twoSum(nums, cases[i].numsSize, cases[i].target, returnSize); // Step 3: 验证结果 if (cases[i].expected[0] -1) { // 期望无解 if (result NULL returnSize 0) { printf(PASS (no solution)\n); passed; } else { printf(FAIL (expected NULL, got [%d,%d] with size %d)\n, result ? result[0] : -1, result ? result[1] : -1, returnSize); } } else { // 期望有解 if (result ! NULL returnSize 2 result[0] cases[i].expected[0] result[1] cases[i].expected[1]) { printf(PASS\n); passed; } else { printf(FAIL (expected [%d,%d], got [%d,%d] with size %d)\n, cases[i].expected[0], cases[i].expected[1], result ? result[0] : -1, result ? result[1] : -1, returnSize); } } // Step 4: 模拟 LeetCode —— free 返回的 resultOJ 会做我们测试时也要做 if (result ! NULL) { free(result); } free(nums); // free 输入数组 } printf(\nSummary: %d / %d tests passed\n, passed, numCases); return (passed numCases) ? 0 : 1; }这个测试文件的精妙之处createArray函数确保输入数组是malloc来的和 LeetCode 行为一致int returnSize; ... returnSize完全复刻接口调用returnSize就是 OJ 传给你的那个指针free(result)和free(nums)主动释放防止测试过程中内存泄漏掩盖真正问题对NULL和returnSize 0的显式检查覆盖无解 case这是很多新手忽略的边界。4.3 常见问题排查ASan 报错的三类典型现场当你运行./test_twoSum并看到 ASan 报错时别慌。以下是三个最高频、最典型的报错场景附带现象、原因和一招毙命的解决方法现象 1ERROR: AddressSanitizer: heap-buffer-overflow on address 0x602000000018 at pc 0x000000401234 bp 0x7ff... sp 0x7ff... READ of size 4原因你的代码试图读取nums数组之外的内存。最常见于循环变量j写成了j numsSize应为导致nums[j]访问越界。解决检查所有for循环的终止条件确保是i numsSize不是i numsSize。用printf(i%d, numsSize%d\n, i, numsSize);打印调试。现象 2ERROR: AddressSanitizer: heap-use-after-free on address 0x602000000018 at pc 0x000000401234 bp 0x7ff... sp 0x7ff... READ of size 4原因你对一块已经free过的内存进行了读或写。例如在哈希法中freeMap(map)后又不小心调用了find(map, x)。解决在freeMap(map)后立即给map.buckets数组所有元素赋NULL在freeMap函数内部做并在find/insert开头加if (map.buckets[i] NULL) return ...防御性检查。现象 3ERROR: AddressSanitizer: stack-buffer-overflow on address 0x7ff... at pc 0x000000401234 bp 0x7ff... sp 0x7ff... WRITE of size 4原因你返回了栈上局部数组的地址。例如int res[2] {i,j}; return res;。res在函数返回后即销毁指针变野。解决永远、永远、永远用malloc分配返回数组。删掉所有int res[2]的写法。这是 C 语言 LeetCode 的铁律。提示ASan 的报错信息里READ of size 4表示读了 4 字节一个intWRITE表示写了。地址0x602...是堆地址0x7ff...是栈地址看地址就能快速定位是堆还是栈问题。5. 二次开发指南如何安全地扩展功能、添加新算法、或集成到你的项目中拿到这个源码包你的终极目标不是“跑通一个题”而是把它变成你自己的 C 语言刷题工具箱。这一章不讲虚的直接给三个可立即上手的改造技巧每个都经过实测且规避了最常见的集成陷阱。5.1 技巧一添加第三种算法——双指针法Two Pointers并安全处理排序副作用双指针法要求数组有序但 LeetCode 的nums是只读的。直接qsort会修改原数组违反契约。正确做法是创建索引数组对索引排序而非对nums排序。// 在 src/twoSum.c 中新增函数 #include stdlib.h // 索引比较函数用于 qsort int compareIndex(const void* a, const void* b) { int i1 *(int*)a; int i2 *(int*)b; // 按 nums[i1] 的值升序排列索引 return (nums[i1] nums[i2]) - (nums[i1] nums[i2]); } // 双指针法实现需在函数外声明 nums 为全局不用闭包思想通过参数传递 // 正确做法将 nums 作为参数传入比较函数——但 qsort 不支持。所以改用静态变量仅限此 demo static int* global_nums NULL; static int global_numsSize 0; int compareIndexStatic(const void* a, const void* b) { int i1 *(int*)a; int i2 *(int*)b; return (global_nums[i1] global_nums[i2]) - (global_nums[i1] global_nums[i2]); } int* twoSumTwoPointers(int* nums, int numsSize, int target, int* returnSize) { *returnSize 2; int* result (int*)malloc(2 * sizeof(int)); if (result NULL) { *returnSize 0; return NULL; } // Step 1: 创建索引数组 [0, 1, 2, ..., numsSize-1] int* indices (int*)malloc(numsSize * sizeof(int)); if (indices NULL) { free(result); *returnSize 0; return NULL; } for (int i 0; i numsSize; i) { indices[i] i; } // Step 2: 设置全局变量临时方案生产环境应重构为结构体 global_nums nums; global_numsSize numsSize; // Step 3: 对 indices 数组排序依据 nums[indices[i]] 的值 qsort(indices, numsSize, sizeof(int), compareIndexStatic); // Step 4: 双指针扫描 int left 0, right numsSize - 1; while (left right) { int sum nums[indices[left]] nums[indices[right]]; if (sum target) { // 找到的是排序后的索引需映射回原下标 int idx1 indices[left]; int idx2 indices[right]; // 确保返回下标升序LeetCode 不强制但好看 if (idx1 idx2) { int tmp idx1; idx1 idx2; idx2 tmp; } result[0] idx1; result[1] idx2; free(indices); return result; } else if (sum target) { left; } else { right--; } } // 未找到 free(indices); free(result); *returnSize 0; return NULL; }集成要点indices数组是malloc来的必须freeglobal_nums是临时 hack真实项目应将nums和numsSize封装进一个struct TwoSumContext并将比较函数改为接受void* ctx双指针法时间复杂度 O(n log n)空间 O(n)适合numsSize极大且内存充足场景。5.2 技巧二将twoSum封装为通用库供其他.c文件调用你想在自己的main.c里调用twoSum不能直接#include src/twoSum.c。正确姿势是确保src/twoSum.h声明完整已提供在你的main.c中#include src/twoSum.h编译时链接twoSum.o。示例my_main.c// my_main.c #include stdio.h #include stdlib.h #include src/twoSum.h // 包含头文件 int main() { int nums[] {2, 7, 11, 15}; int numsSize 4; int target 9; int returnSize; int* result twoSum(nums, numsSize, target, returnSize); if (result ! NULL returnSize 2) { printf(Found: [%d, %d]\n, result[0], result[1]); free(result); // 记住 free } else { printf(Not found\n); } return 0; }编译命令gcc -g -fsanitizeaddress -Isrc my_main.c src/twoSum.c -o my_main关键提醒twoSum.c中的哈希实现initMap,insert等是static的不会污染全局命名空间可安全复用。5.3 技巧三为twoSum添加日志但绝不污染 LeetCode 提交你想加printf(Debug: i%d, nums[i]%d\n, i, nums[i]);调试直接加会因stdout冲突被 LeetCode 判为 WA。解决方案用预处理器宏控制日志开关。在src/twoSum.h顶部添加#ifndef TWO_SUM_DEBUG #define TWO_SUM_DEBUG 0 #endif #if TWO_SUM_DEBUG #include stdio.h #define LOG(fmt, ...) printf([TWO_SUM] fmt \n, ##__VA_ARGS__) #else #define LOG(fmt, ...) #endif在twoSum.c中使用for (int i 0; i numsSize; i) { LOG(Processing i%d, nums[i]%d, i, nums[i]); ... }编译时控制本地调试gcc -DTWO_SUM_DEBUG1 ...提交 LeetCode不加-DLOG展开为空零开销。从那以后我每次写 C 语言 LeetCode 题第一件事就是检查returnSize是否赋值、malloc是否配对free、以及所有数组访问是否带 numsSize边界。这三个动作我强制自己在git commit前用grep -n returnSize\|malloc\|free\| numsSize src/*.c过一遍。不是信不过自己是信不过 C 语言在裸金属上那点脆弱的确定性。希望帮到你。本文还有配套的精品资源点击获取