LeetCode两数之和问题解析与C#实现-代码聚汇网

LeetCode两数之和问题解析与C#实现

周传炽·2026-10-30·阅读 24 GEO检测（免费）

两数之和LeetCode算法

|难度：普通|阅读约 10 分钟

1. 两数之和问题概述

两数之和（Two Sum）是LeetCode题库中的第一道题目，也是算法入门必刷的经典问题。题目要求在一个整数数组中找到两个数，使它们的和等于给定的目标值，并返回这两个数的数组下标。

这道题之所以被放在LeetCode的第一题，是因为它完美地展示了算法设计中最基本的"暴力解法"与"优化解法"之间的思维差异。作为算法学习的起点，它帮助我们理解时间复杂度分析的重要性，以及如何利用数据结构来优化算法性能。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 问题描述与输入输出分析

2.1 题目详细描述

给定一个整数数组nums和一个整数目标值target，需要在数组中找出和为目标值的那两个整数，并返回它们的数组下标。题目明确说明：

每种输入只会对应一个答案
不能重复使用同一个元素（即不能使用nums[i] + nums[i] = target的情况）
可以按任意顺序返回答案

示例：

code复制输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为nums[0] + nums[1] == 9，返回[0,1]

2.2 输入输出约束条件

在实际编码前，我们需要明确问题的边界条件：

数组长度范围：2 ≤ nums.length ≤ 10^4
元素值范围：-10^9 ≤ nums[i] ≤ 10^9
目标值范围：-10^9 ≤ target ≤ 10^9
只会存在一个有效答案
不能使用相同元素两次

这些约束条件直接影响我们的算法设计。例如，数组长度可能达到10^4，这意味着O(n^2)的暴力解法虽然能通过，但效率不高；而元素值范围很大，需要考虑数值溢出的问题。

3. C#解法实现

3.1 暴力解法（Brute Force）

最直观的解法是使用双重循环遍历所有可能的数对组合：

csharp复制public int[] TwoSum(int[] nums, int target) {
    for (int i = 0; i < nums.Length; i++) {
        for (int j = i + 1; j < nums.Length; j++) {
            if (nums[i] + nums[j] == target) {
                return new int[] { i, j };
            }
        }
    }
    return new int[0]; // 题目保证有解，这行实际上不会执行
}

时间复杂度分析：

外层循环执行n次
内层循环平均执行n/2次
总时间复杂度为O(n^2)

空间复杂度：O(1)，只使用了常数个额外空间

虽然这种解法简单直接，但对于大型数组（如长度接近10^4时），性能会明显下降。在LeetCode上提交时，这个解法大约需要300-400ms执行时间。

3.2 哈希表优化解法

我们可以利用哈希表（在C#中是Dictionary）来存储已经遍历过的元素及其索引，将查找时间从O(n)降低到O(1)：

csharp复制public int[] TwoSum(int[] nums, int target) {
    Dictionary<int, int> numDict = new Dictionary<int, int>();
    for (int i = 0; i < nums.Length; i++) {
        int complement = target - nums[i];
        if (numDict.ContainsKey(complement)) {
            return new int[] { numDict[complement], i };
        }
        numDict[nums[i]] = i;
    }
    return new int[0];
}

时间复杂度分析：

只需一次遍历，每个元素处理时间为O(1)
总时间复杂度为O(n)

空间复杂度：O(n)，最坏情况下需要存储n-1个元素

这种解法在LeetCode上的执行时间约为200-250ms，比暴力解法快了约30%。对于大型数组，这种优势会更加明显。

注意：在C#中使用Dictionary时要注意键值冲突问题。虽然题目保证答案唯一，但如果数组中有重复元素，后出现的会覆盖先出现的。不过这不影响最终结果，因为我们只需要找到一个解。

4. 边界条件与异常处理

虽然题目保证输入有效，但实际工程中我们需要考虑更多边界情况：

4.1 空数组或单元素数组

虽然题目保证数组长度≥2，但实际代码中可以添加防御性检查：

csharp复制if (nums == null || nums.Length < 2) {
    throw new ArgumentException("Input array must contain at least two elements");
}

4.2 数值溢出

当处理极大或极小的数值时，相加可能导致溢出：

csharp复制int complement = target - nums[i];
// 检查是否溢出
if ((nums[i] > 0 && complement > target) || (nums[i] < 0 && complement < target)) {
    continue; // 或者抛出异常
}

4.3 哈希表容量初始化

对于大型数组，预先设置Dictionary的容量可以避免多次扩容：

csharp复制Dictionary<int, int> numDict = new Dictionary<int, int>(nums.Length);

5. 算法优化与变种

5.1 双指针解法（适用于已排序数组）

如果数组已排序，可以使用双指针法，时间复杂度O(n)，空间复杂度O(1)：

csharp复制public int[] TwoSumSorted(int[] nums, int target) {
    int left = 0, right = nums.Length - 1;
    while (left < right) {
        int sum = nums[left] + nums[right];
        if (sum == target) {
            return new int[] { left, right };
        }
        else if (sum < target) {
            left++;
        }
        else {
            right--;
        }
    }
    return new int[0];
}

虽然原题不保证数组有序，但这是一个常见的变种问题，很多后续题目（如三数之和）都基于此解法。

5.2 多语言实现比较

比较不同语言的实现方式有助于深入理解算法：

Java: 使用HashMap，与C#类似
Python: 使用字典，语法更简洁
C++: 使用unordered_map，需要注意哈希冲突
JavaScript: 使用对象或Map，注意键会被转换为字符串

6. 实际工程中的应用

两数之和算法在实际工程中有广泛应用场景：

金融交易系统：查找匹配的买卖订单
数据库查询优化：某些JOIN操作可以转化为两数之和问题
缓存系统：检查是否存在互补的缓存项
游戏开发：物品组合效果检查

例如，在电商系统中，我们可能需要找到两件商品的总价正好等于用户的优惠券面额：

csharp复制public List<ProductPair> FindProductPairs(Product[] products, decimal targetAmount) {
    var result = new List<ProductPair>();
    var productDict = new Dictionary<decimal, Product>();
    
    foreach (var product in products) {
        decimal complement = targetAmount - product.Price;
        if (productDict.TryGetValue(complement, out var matchedProduct)) {
            result.Add(new ProductPair(product, matchedProduct));
        }
        productDict[product.Price] = product;
    }
    
    return result;
}

7. 常见错误与调试技巧

7.1 初学者常见错误

返回元素值而非索引：

csharp复制// 错误示范
return new int[] { nums[i], nums[j] }; // 应该返回索引i,j

使用相同元素两次：

csharp复制// 错误示范
for (int j = 0; j < nums.Length; j++) // 应该从i+1开始

忽略哈希冲突：

csharp复制// 可能覆盖先前值
numDict[nums[i]] = i; // 如果nums有重复值，会覆盖

7.2 调试技巧

打印中间结果：

csharp复制Console.WriteLine($"Checking i={i}, nums[i]={nums[i]}, complement={complement}");

使用单元测试：

csharp复制[TestMethod]
public void TestTwoSum() {
    var solution = new Solution();
    var result = solution.TwoSum(new int[] { 2, 7, 11, 15 }, 9);
    CollectionAssert.AreEqual(new int[] { 0, 1 }, result);
}

性能分析：

csharp复制var stopwatch = Stopwatch.StartNew();
// 调用算法
stopwatch.Stop();
Console.WriteLine($"Execution time: {stopwatch.ElapsedMilliseconds}ms");

8. 扩展学习与相关题目

掌握两数之和后，可以挑战以下相关题目：

三数之和（3Sum） - LeetCode 15
四数之和（4Sum） - LeetCode 18
两数之和 II - 输入有序数组（Two Sum II） - LeetCode 167
两数之和 IV - 输入BST（Two Sum IV） - LeetCode 653
小于K的两数之和（Two Sum Less Than K） - LeetCode 1099

这些题目在两数之和的基础上增加了新的约束条件或数据结构，是很好的进阶练习。

对于想要深入算法学习的开发者，建议按照以下路径系统学习：

掌握基本数据结构：数组、链表、哈希表、栈、队列
学习基础算法：排序、搜索、递归
练习经典题目：两数之和、反转链表、二叉树遍历
学习高级算法：动态规划、贪心算法、图算法

两数之和作为算法学习的起点，其重要性不仅在于题目本身，更在于它教会我们如何分析问题、优化解法，以及理解时间空间复杂度的权衡。在实际编码中，我经常使用哈希表优化的解法，它不仅效率高，而且代码简洁。对于C#开发者来说，熟练掌握Dictionary的使用是算法实现的关键。