从零基础学Go(八)——写道简单算法题

两数之和

给定一个整数数组 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
• 只会存在一个有效答案

首先我们先分析一下这个题目要我们做什么。这个题目是一个经典的算法问题，它要求你在一个整数数组 nums 中找到两个数，使得这两个数的和等于一个给定的目标值 target。你需要找到这两个数的下标，并返回它们。

问题的具体要求如下：

1. 输入：一个整数数组 nums 和一个整数 target。
2. 输出：一个包含两个整数的数组，这两个整数是 nums 中的下标，它们对应的元素相加等于 target。
3. 条件：每种输入只会有一个有效的答案，且不能使用相同的元素两次。

这个问题的关键在于如何高效地找到这两个数。

首先第一点大家肯定都能想到，我用暴力解决！所有可能性我都算一遍肯定能找着。暴力法虽然性能开销较大，但有些时候暴力法不失为一种好的解决方式。

暴力法

遍历数组中的每个元素，对于每个元素，再次遍历数组来查找是否存在另一个元素使得它们的和等于 target。这种方法的时间复杂度是 O(n^2)，其中 n 是数组的长度。

package main

import "fmt"

func twoSum(nums []int, target int) []int {
    n := len(nums)
    for i := 0; i < n; i++ {
        for j := i + 1; j < n; j++ {
            if nums[i]+nums[j] == target {
                return []int{i, j}
            }
        }
    }
    return []int{} // 如果没有找到答案，返回空切片
}

func main() {
    // 示例
    fmt.Println(twoSum([]int{2, 7, 11, 15}, 9)) // 输出: [0, 1]
    fmt.Println(twoSum([]int{3, 2, 4}, 6))      // 输出: [1, 2]
    fmt.Println(twoSum([]int{3, 3}, 6))         // 输出: [0, 1]
}

这段代码定义了一个 twoSum 函数，它接受一个整数切片 nums 和一个整数 target。函数内部使用两层循环来遍历数组中的每个元素，并检查每对元素的和是否等于 target。如果找到这样的一对元素，就返回它们的下标。如果遍历完数组都没有找到，就返回一个空的切片。

在 main 函数中，我们提供了几个示例来测试 twoSum 函数。虽然这种方法在小数组上效率可以接受，但在大数组上效率较低。

哈希表

使用一个哈希表来存储遍历过程中每个元素的值和它的下标。对于数组中的每个元素，计算它与 target 的差值，并检查这个差值是否已经在哈希表中。如果在，那么我们就找到了两个数，它们的和等于 target。这种方法的时间复杂度是 O(n)，因为每个元素只被访问一次。

package main

import "fmt"

func twoSum(nums []int, target int) []int {
    // 创建一个字典来存储数字和它的索引
    numToIndex := make(map[int]int)
    for i, num := range nums {
        // 计算差值
        diff := target - num
        // 检查差值是否已经在字典中
        if index, ok := numToIndex[diff]; ok {
            // 如果在，返回这两个数的索引
            return []int{index, i}
        }
        // 如果不在，将当前数和它的索引存入字典
        numToIndex[num] = i
    }
    // 如果没有找到答案，返回空切片
    return []int{}
}

func main() {
    // 示例
    fmt.Println(twoSum([]int{2,7,11,15}, 9))  // 输出: [0, 1]
    fmt.Println(twoSum([]int{3,2,4}, 6))     // 输出: [1, 2]
    fmt.Println(twoSum([]int{3,3}, 6))       // 输出: [0, 1]
}

这段代码定义了一个 twoSum 函数，它接受一个整数切片 nums 和一个整数 target。函数内部使用一个 map 来存储每个元素的值和索引。遍历切片中的每个元素，计算它与目标值的差值，并检查这个差值是否已经在 map 中。如果是，就返回这两个元素的索引。如果遍历完切片都没有找到，就返回一个空的切片。最后，main 函数中提供了几个示例来测试 twoSum 函数。

总结

在解决“两数之和”问题时，我们探讨了两种主要的算法方法：暴力法和哈希表法。暴力法通过两层循环遍历数组，直接寻找两个数的和等于目标值，这种方法简单但效率较低，时间复杂度为 O(n2)。相比之下，哈希表法通过一次遍历并使用哈希表存储元素及其索引，有效将时间复杂度降低到 O(n)，显著提高了算法效率。在实际应用中，哈希表法因其高效性而更受青睐，尤其是在处理大规模数据时。通过Go语言的实现示例，我们可以看到两种方法的具体应用，其中哈希表法不仅代码简洁，而且运行效率高，是解决此类问题的推荐方法。

欢迎关注公众号：“全栈开发指南针”
这里是技术潮流的风向标，也是你代码旅程的导航仪！🚀
Let’s code and have fun! 🎉