LeetCode 热题 100：多语言和多种方法实现“两数之和”问题

多语言和多种方法实现“两数之和”问题

摘要

在本文中，我们将探讨解决“两数之和”问题的不同编程语言实现和多种算法方法。通过比较它们的效率和易用性，我们可以更好地理解不同编程语言和算法策略的优势。

1. 问题描述

给定一个整数数组 nums 和一个整数目标值 target，任务是在数组中找出和为目标值 target 的两个整数，并返回它们的数组下标。

2. 输入和输出格式

• 输入：整数数组 nums 和整数 target
• 输出：整数数组，包含两个下标，表示满足条件的两个整数的位置

3. 示例

• 示例 1：nums = [2,7,11,15], target = 9 输出：[0,1]
• 示例 2：nums = [3,2,4], target = 6 输出：[1,2]
• 示例 3：nums = [3,3], target = 6 输出：[0,1]

4. 约束条件

• 2 <= nums.length <= 10^4
• -10^9 <= nums[i] <= 10^9
• -10^9 <= target <= 10^9
• 只会存在一个有效答案

5. 算法分析

• 暴力解法：遍历数组，对每一对元素进行相加，检查是否等于目标值。时间复杂度为 O(n^2)。
• 哈希表解法：使用哈希表存储已经遍历过的元素及其索引，对于每个元素，检查 target - 当前元素 是否存在于哈希表中。时间复杂度为 O(n)。

6. 多语言实现

我们将使用 Python、Java 和 C++ 来实现上述两种算法。

Python 实现

# 暴力解法
def two_sum_brute(nums, target):
    for i in range(len(nums)):
        for j in range(i+1, len(nums)):
            if nums[i] + nums[j] == target:
                return [i, j]

# 哈希表解法
def two_sum_hash(nums, target):
    num_to_index = {}
    for i, num in enumerate(nums):
        if target - num in num_to_index:
            return [num_to_index[target - num], i]
        num_to_index[num] = i

Java 实现

// 暴力解法
public int[] twoSumBrute(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]; // 不应该到达这里
}

// 哈希表解法
public int[] twoSumHash(int[] nums, int target) {
    Map<Integer, Integer> numToIndex = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (numToIndex.containsKey(complement)) {
            return new int[]{numToIndex.get(complement), i};
        }
        numToIndex.put(nums[i], i);
    }
    return new int[0]; // 不应该到达这里
}

C++ 实现

// 暴力解法
vector<int> twoSumBrute(vector<int>& nums, int target) {
    for (int i = 0; i < nums.size(); i++) {
        for (int j = i + 1; j < nums.size(); j++) {
            if (nums[i] + nums[j] == target) {
                return {i, j};
            }
        }
    }
    return {}; // 不应该到达这里
}

// 哈希表解法
vector<int> twoSumHash(vector<int>& nums, int target) {
    unordered_map<int, int> numToIndex;
    for (int i = 0; i < nums.size(); i++) {
        int complement = target - nums[i];
        if (numToIndex.find(complement) != numToIndex.end()) {
            return {numToIndex[complement], i};
        }
        numToIndex[nums[i]] = i;
    }
    return {}; // 不应该到达这里
}

7. 测试用例

• 测试用例 1：nums = [2,7,11,15], target = 9
• 测试用例 2：nums = [3,2,4], target = 6
• 测试用例 3：nums = [3,3], target = 6

8. 测试结果

• 所有测试用例在所有语言实现中都应该返回正确的结果。

9. 总结

通过实现和比较不同语言和算法方法，我们可以看到使用哈希表的方法在时间复杂度上具有明显优势，适用于大规模数据集。同时，不同编程语言在语法和库支持上各有特点，选择合适的语言可以提高开发效率。

10. 参考文献

• LeetCode: Two Sum Problem

11. 相关标签

• 算法
• 编程语言
• Python
• Java
• C++
• 数据结构

12. 相关企业

• Google
• Facebook
• Amazon
• Microsoft

13. 提示

• 在实现算法时，考虑边界条件和异常处理。
• 优化代码以提高性能和可读性。