一、题目描述

给定一个整数数组 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) 的算法吗？

二、我的题解

1. 遍历法

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

结果：

这种解法：

时间复杂度：O(N²)，其中 N 是数组中的元素数量。
空间复杂度：O(1)。

2. 把题目稍微变一下

实际上，题目中 “假设每种输入只会对应一个答案” 是不符合实际情况的。

一般在一个数组中，其和为同一个数的两个数字有很多对，所以我把题目中函数的返回值类型改为了 [][]int，这样就能输出所有和为 target 的数字对了。

package main

import (
	"fmt"
)

func main() {
	nums := []int{0, 8, 2, 3, 6, 4}
	target := 6
	result := twoSum(nums, target)
	fmt.Println(result)
}

func twoSum(nums []int, target int) [][]int {

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

三、别人更好的解法 – 哈希表

创建一个哈希表，对于每一个 x，我们首先查询哈希表中是否存在 target – x，然后将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。

package main

import (
	"fmt"
)

func main() {
	nums := []int{7, 8, 2, 3, 6, 4}
	target := 12
	result := twoSum(nums, target)
	fmt.Println(result)
}

func twoSum(nums []int, target int) []int {
	//建一个空的哈希表
	hashTable := map[int]int{}

	//遍历nums
	for i, x := range nums {

		if p, ok := hashTable[target-x]; ok { //判断某个键是否存在，若存在就返回相应的值和true
			return []int{p, i}
		}
		//向哈希表里赋值
		hashTable[x] = i //将原nums的索引和值翻转，这样值就变成了键
		//哈希表赋值语句只能放在if后面，为了避免数组中的同一个元素重复出现

	}
	return nil
}