1. 两数之和 - 力扣（LeetCode）

基础知识要求：

Java：方法、map集合、泛型、for循环、if语句、数组、Arrays.toString()工具类方法、算术运算符

Python： 方法、for循环（enumerate()方法）、字典、if in语句、for循环、列表、

题目： 

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

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

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

• 2 <= nums.length <= 104
• -109 <= nums[i] <= 109
• -109 <= target <= 109
• 只会存在一个有效答案

进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？

思路解析：

这个问题可以使用哈希表（在Python中通常使用字典）来解决，具体思路如下：

1. 遍历数组 nums。
2. 对于当前遍历到的数字 num，计算 complement = target - num，即目标值与当前数字的差值。
3. 检查 complement 是否已经在哈希表中出现过。如果出现过，说明找到了两个数字的和为目标值，返回这两个数字在数组中的索引（complement 的索引和当前数字的索引）。
4. 如果 complement 没有在哈希表中出现过，则将当前数字 num 和其索引作为键值对存入哈希表中，以便后续检查。

Java代码示例：

// 导入Java的HashMap和Map接口  
import java.util.HashMap;    
import java.util.Map;    
  
// 定义一个名为TwoSum的类  
public class TwoSum {    
  
    // 定义一个名为twoSum的方法，它接收一个整数数组nums和一个整数target，并返回一个整数数组  
    public int[] twoSum(int[] nums, int target) {    
        // 创建一个HashMap来存储数组中的元素及其索引  
        Map<Integer, Integer> numMap = new HashMap<>();    
  
        // 遍历数组nums  
        for (int i = 0; i < nums.length; i++) {    
            // 计算当前元素与目标值的差值  
            int complement = target - nums[i];    
  
            // 检查差值是否已经在HashMap中存在  
            if (numMap.containsKey(complement)) {    
                // 如果存在，则返回差值对应的索引和当前元素的索引  
                return new int[]{numMap.get(complement), i};    
            }    
  
            // 如果差值不存在，则将当前元素及其索引添加到HashMap中  
            numMap.put(nums[i], i);    
        }    
  
        // 如果没有找到解，则抛出IllegalArgumentException异常（或根据题目要求返回null）  
        throw new IllegalArgumentException("No two sum solution");    
    }    
  
    // 主方法，程序的入口点  
    public static void main(String[] args) {    
        // 创建一个TwoSum对象  
        TwoSum solution = new TwoSum();    
  
        // 测试用例1  
        int[] nums = {2, 7, 11, 15};    
        int target = 9;    
        int[] indices = solution.twoSum(nums, target);    
        // 导入Arrays类来打印数组（注意：在实际代码中需要导入java.util.Arrays）  
        System.out.println(Arrays.toString(indices)); // 输出: [0, 1]    
  
        // 测试用例2  
        nums = new int[]{3, 2, 4};    
        target = 6;    
        indices = solution.twoSum(nums, target);    
        System.out.println(Arrays.toString(indices)); // 输出: [1, 2]    
  
        // 测试用例3  
        nums = new int[]{3, 3};    
        target = 6;    
        indices = solution.twoSum(nums, target);    
        System.out.println(Arrays.toString(indices)); // 输出: [0, 1]    
    }    
}    
  
// 注意：在实际代码中，需要导入java.util.Arrays类来使用Arrays.toString()方法  
// import java.util.Arrays;

Python代码示例：

# 定义一个名为twoSum的函数，该函数接收两个参数：一个整数列表nums和一个整数target  
def twoSum(nums, target):  
    # 创建一个空字典num_dict，用于存储nums中的数字和它们对应的索引  
    num_dict = {}  # 用于存储数字和它们的索引  
  
    # 遍历nums列表，同时获取每个元素的索引i和值num  
    for i, num in enumerate(nums):  
        # 计算当前元素与目标值的差值，这个差值就是我们需要的“补数”  
        complement = target - num  
  
        # 检查补数是否已经在num_dict字典中  
        if complement in num_dict:  
            # 如果找到了补数，则返回补数对应的索引和当前元素的索引（注意顺序）  
            return [num_dict[complement], i]  
  
        # 如果补数不在字典中，则将当前元素num和它的索引i添加到字典中  
        num_dict[num] = i  
  
    # 如果循环结束后仍未找到满足条件的两个数，则返回None（或者其他合适的值）  
    return None  # 如果没有找到，返回None或者其他合适的值  
  
# 示例  
# 第一个示例  
nums = [2, 7, 11, 15]  
target = 9  
print(twoSum(nums, target))  # 输出: [0, 1]，因为2和7的和为9，它们在nums中的索引分别是0和1  
  
# 第二个示例  
nums = [3, 2, 4]  
target = 6  
print(twoSum(nums, target))  # 输出: [1, 2]，因为2和4的和为6，它们在nums中的索引分别是1和2  
  
# 第三个示例  
nums = [3, 3]  
target = 6  
print(twoSum(nums, target))  # 输出: [0, 1]，因为两个3的和为6，它们在nums中的索引分别是0和1