给定一个无序数组和一个目标值，找出数组中两个数之和等于目标值的所有组合

题目：

给定一个无序数组和一个目标值，找出数组中两个数之和等于目标值的所有组合，并给出时间复杂度。

假设数组是[3,5,3,5]，目标值是8。
答案是否可重复，题里没说，所以分3种情况，如下：

1.重复。答案是【0，1】【0，3】【1，2】【2，3】，序号组合，共4种组合。
解法如下：
1.1.嵌套遍历。时间复杂度：O(n^2)。
1.2.哈希法。键存数组元素值，值存出现次数。时间复杂度：O(n)。
1.3.排序+双指针夹逼。时间复杂度：O(nlogn)。

2.半重复。答案是【0，1】【2，3】，也可能是【0，3】【1，2】，序号组合，共2种组合。
解法如下：
2.1.嵌套遍历。时间复杂度：O(n^2)。
2.2.哈希法。键存数组元素值，值存出现次数。时间复杂度：O(n)。
2.3.排序+双指针夹逼。时间复杂度：O(nlogn)。

3.不重复。答案是[3,5]，值组合，共1种组合。
解法如下：
3.1.嵌套遍历。时间复杂度：O(n^2)。
3.2.哈希法。键存数组元素值，值不存。时间复杂度：O(n)。
3.3.排序+双指针夹逼。时间复杂度：O(nlogn)。
3.4.位图法。时间复杂度：O(目标值)。

代码采用3.2方式，

用golang实现如下：

package main

import "fmt"

func main() {
    nums := []int{3, 5, 3, 5, 4, 4}
    target := 8
    for k, _ := range twoSum(nums, target) {
        fmt.Println(k, "+", target-k, "=", target)
    }
}

func twoSum(nums []int, target int) map[int]struct{} {
    map0 := make(map[int]struct{}) //缓存，哈希保存
    ret := make(map[int]struct{})  //保存结果

    for i := 0; i < len(nums); i++ {
        complement := target - nums[i]     //差值 = 目标值-元素值
        if _, ok := map0[complement]; ok { //如果字典里有差值，说明已经找到了
            if complement < nums[i] {
                ret[complement] = struct{}{}
            } else {
                ret[nums[i]] = struct{}{}
            }
        }
        //如果字典里没有差值，缓存数组的当前值
        map0[nums[i]] = struct{}{}
    }

    return ret
}