leetcode算法：1.两数之和

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

思考

考虑空间复杂度

1. 要求空间复杂度O(1)
2. 允许空间复杂度O(n)

解答

• 对于要求空间复杂度O(1)的这种情况，只能双层循环暴力搜索了，也就是看到这道题的第一简单粗暴解法。
• 对于允许空间复杂度O(n)的这种情况，就是典型的空间换时间了，利用一个外部map(dict)来边检索边存储。

 

package algo

func twoSum(nums []int, target int) []int {
	if len(nums) < 2 {	//数组长度<2时无意义
		return nil
	}
	
	elemMap := make(map[int]int)
	for i := 0; i < len(nums); i++ {
		if j, ok := elemMap[target-nums[i]]; ok {
			return []int{j, i}	//index顺序为先j后i，因为j是之前搜索时放进去的，因此j一定在i前
		}
		elemMap[nums[i]] = i
	}
	return nil
}

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

单元测试：

package algo

import (
	"math/rand"
	"testing"
	"time"
)

func TestTwoSum(t *testing.T) {
	rand.Seed(int64(time.Now().Nanosecond()))
	for times := 0; times < 10; times++ {
		nums := []int{}
		for i := 0; i < 100; i++ {
			nums = append(nums, rand.Intn(100))
		}
		res := twoSum(nums, 128)
		if res == nil {
			t.Error("failed")
		}
	}
}

func TestTwoSum_BruteForce(t *testing.T) {
	rand.Seed(int64(time.Now().Nanosecond()))
	for times := 0; times < 10; times++ {
		nums := []int{}
		for i := 0; i < 100; i++ {
			nums = append(nums, rand.Intn(100))
		}
		res := twoSum_BruteForce(nums, 128)
		if res == nil {
			t.Error("failed")
		}
	}
}