Leecode.1 两数之和

本文深入探讨了经典的两数之和问题,提供两种高效解决方案:暴力破解与取差值算法。前者通过双层循环查找匹配项,后者利用哈希映射优化搜索过程,实现快速配对。
  • 题目:

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

你可以假设每种输入只会对应一个答案。但是,你不能重复利用这个数组中同样的元素。


  • 示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]


个人总结两种解法:

  1. 暴击破解法
  2. 取差值算法

1. 暴力破解

采用双层循环,遍历数组中各个数字的和,取出和等于目标的两个数返回,时间复杂度为O(n),不需要额外的空间

代码如下:

func twoSum(nums []int, target int) []int {
    result := []int{}
    length := len(nums)
    
    for i := 0; i < length - 1; i++ {
        for j := i+1; j < length; j++ {
            if nums[i] + nums[j] == target {
                result = append(result, i, j)
                return result
            }
        }
    }
    
    return result
}

2. 取差值算法

循环遍历数组中的数据,并将target与nums[i]的差放入map数组中,从第二个元素起,判断元素是否存在map数组中,如果存在,把当前元素的下标和map数组中的值取出来返回。

时间复杂度为O(n),

由于使用了额外的map数组,空间复杂度为O(n)

func twoSum(nums []int, target int) []int {
	subs := make(map[int]int)
	result := []int{}

	for i := 0; i < len(nums); i++ {
		if tmp, ok := subs[nums[i]]; ok {
			result = append(result, tmp, i)
			return result
		}

		sub := target - nums[i]
		subs[sub] = i
	}

	return result
}

本题就到这里了,希望共同进步。

 

<think>首先,用户的问题是:“我想使用Java解决LeetCode算法题中的两数之和问题 请问LeetCode Java实现 两数之和问题解决方案”。这直接指向LeetCode的第一题“Two Sum”。 根据系统级指令: - 所有行内数学表达式必须使用$...$格式。 - 独立公式必须使用$$...$$$$格式并单独成段。 - LaTeX语法正确。 - 使用中文回答。 - 生成相关问题。 - 在回答中引用的段落末尾自然地添加引用标识。 - 回答结构清晰,帮助用户逐步解决问题,保证真实可靠。 用户可见层要求回答结构清晰,帮助用户逐步解决问题。 参考的引用是关于LeetCode两数之和问题的Java实现: - 引用[1]:描述问题背景。 - 引用[2]:暴力解法代码。 - 引用[3]:暴力解法代码。 - 引用[4]:暴力解法代码。 - 引用[5]:暴力解法代码。 所有引用都展示了暴力解法,即双重循环。但我知道两数之和问题有更高效的解法,比如使用哈希表。我应该提供最优解。 标准解决方案: - 暴力法:时间复杂度$O(n^2)$,空间复杂度$O(1)$。 - 哈希表法:时间复杂度$O(n)$,空间复杂度$O(n)$。 用户要求Java实现,所以我需要提供代码。 回答结构: 1. **介绍问题**:简要描述LeetCode两数之和问题。 2. **解决方案**: - 解释暴力解法(因为引用中提到,可以作为基础)。 - 解释优化解法(哈希表法)。 - 提供Java代码。 3. **逐步解释**:确保清晰,帮助用户理解。 4. **生成相关问题**:在末尾添加相关问题。 5. **引用标识**:如果引用站内内容,在末尾添加引用标识。引用中提到了暴力解法,所以我可以在提到暴力解法时添加引用。 引用内容: - 引用[2][3][4][5]都提供了暴力解法的代码。我可以参考这些,但需要自然添加引用标识。 例如,在描述暴力解法时,可以说“如引用[2]所示”。 现在,构建回答大纲: - **开头**:介绍问题。 - **暴力解法**:解释和代码,添加引用标识。 - **优化解法**:哈希表法,解释和代码。 - **比较**:简要比较两种方法。 - **结尾**:总结。 - **相关问题**:生成相关问题。 使用中文回答。 数学表达式:如果涉及数学,如时间复杂度,使用$...$。 例如: - 时间复杂度:$O(n^2)$ 或 $O(n)$。 独立公式:可能不需要,因为主要是代码。 现在,写回答。</think>### LeetCode 两数之和问题 Java 解决方案 您好!LeetCode 的“两数之和”问题(题目编号:1)是一个经典算法题。给定一个整数数组 `nums` 和一个目标值 `target`,要求找出数组中两个数的索引,使得它们的和等于 `target`。假设每个输入只有一个解,且不能重复使用同一元素。我将逐步解释两种 Java 实现方法:暴力解法和优化解法(哈希表法)。所有代码都基于 LeetCode 官方题解和常见实践,确保真实可靠。我会先介绍问题背景,然后提供代码和详细解释。 #### 问题描述 给定一个数组 `nums` 和目标值 `target`,找出两个索引 `i` 和 `j`($i \neq j$),使得 $nums[i] + nums[j] = target$。例如,输入 `nums = [2, 7, 11, 15]`, `target = 9`,输出应为 `[0, 1]`(因为 $2 + 7 = 9$)。 #### 解决方案 1: 暴力解法(双重循环) 这是最直观的方法:遍历数组中的每个元素,对于每个元素 `nums[i]`,再遍历其后的元素 `nums[j]`($j > i$),检查是否满足 $nums[i] + nums[j] = target$。如果找到,立即返回索引对。 - **时间复杂度**:$O(n^2)$,其中 $n$ 是数组长度。因为需要两层循环。 - **空间复杂度**:$O(1)$,不使用额外空间。 - **优点**:实现简单,适合小规模数组。 - **缺点**:效率低,当 $n$ 较大时性能差。 以下是 Java 代码实现(基于引用[2][3][5]的暴力解法): ```java public class Solution { public int[] twoSum(int[] nums, int target) { // 遍历每个元素 for (int i = 0; i < nums.length - 1; i++) { // 对于当前元素 nums[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]; } } ``` **代码解释**: - 外层循环从索引 `i = 0` 开始,遍历到 `nums.length - 1`(因为最后一个元素无需作为起始点)。 - 内层循环从 `j = i + 1` 开始,避免重复比较(如引用[3]所述,这样可以减少不必要的计算)。 - 当发现 `nums[i] + nums[j] == target` 时,直接返回 `new int[]{i, j}`。 - 如果遍历完无解,返回空数组 `new int[0]`(尽管题目保证有解,但代码需健壮性)。 此方法简单易懂,但效率不高,适合初学者理解问题本质[^2][^3][^5]。 #### 解决方案 2: 优化解法(哈希表法) 为了提高效率,可以使用哈希表(HashMap)存储元素值及其索引。遍历数组时,检查 `target - nums[i]` 是否已存在于哈希表中。如果存在,说明找到了解;否则,将当前元素存入哈希表。这避免了嵌套循环。 - **时间复杂度**:$O(n)$,只需一次遍历。 - **空间复杂度**:$O(n)$,哈希表最多存储 $n$ 个元素。 - **优点**:高效,适合大规模数组。 - **缺点**:使用额外空间,但通常可接受。 以下是 Java 代码实现(基于 LeetCode 官方推荐): ```java import java.util.HashMap; import java.util.Map; public class Solution { public int[] twoSum(int[] nums, int target) { // 创建哈希表,键为元素值,值为索引 Map<Integer, Integer> numMap = new HashMap<>(); // 遍历数组 for (int i = 0; i < nums.length; i++) { int complement = target - nums[i]; // 计算补数 // 检查补数是否在哈希表中 if (numMap.containsKey(complement)) { // 如果存在,返回当前索引和补数的索引 return new int[]{numMap.get(complement), i}; } // 将当前元素存入哈希表(值作为键,索引作为值) numMap.put(nums[i], i); } // 无解时返回空数组 return new int[0]; } } ``` **代码解释**: - 初始化一个 `HashMap`,键(key)存储元素值,值(value)存储对应索引。 - 遍历数组:对于每个 `nums[i]`,计算 `complement = target - nums[i]`。 - 检查 `complement` 是否在哈希表中:如果存在,说明之前已存储了该值,直接返回 `numMap.get(complement)`(补数的索引)和 `i`(当前索引)。 - 如果未找到,将 `nums[i]` 和 `i` 存入哈希表。 - 这种方法只需一次遍历,效率远高于暴力解法。 #### 方法比较 - **暴力解法**:简单但慢,适用于学习或小数据集($n \leq 1000$)。 - **哈希表法**:推荐解法,速度快,适用于大数据集($n > 1000$)。在实际 LeetCode 提交中,哈希表法通常运行时间在 2-5ms,而暴力解法可能超时(如 $n=10^4$ 时)。 #### 测试示例 在 LeetCode 上测试时,可以使用以下输入验证: - 输入:`nums = [2,7,11,15]`, `target = 9` → 输出:`[0,1]` - 输入:`nums = [3,2,4]`, `target = 6` → 输出:`[1,2]` 确保代码处理边界情况,如数组为空或无解(尽管题目保证有解)。 #### 总结 通过以上两种方法,您可以高效解决 LeetCode 两数之和问题。暴力解法帮助理解基础,哈希表法是实际最优解。建议在 LeetCode 平台上提交代码测试性能。如果您是初学者,先从暴力解法入手,再过渡到哈希表法,以加深对数据结构的理解[^1][^4]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值