100-哈希

1. 两数之和

hash

比较简单，用一个map即可，key是数，value存下标

注意这里用m[target-val] !=-1 !=0都不合适

value, ok := m[key]这样比较好

func twoSum(nums []int, target int) []int {
    
    m := map[int]int{}

    for i, val := range nums {
        
        if _, ok := m[target-val]; ok {
            fmt.Println(i, m[target-val])
            return []int{i, m[target-val]}
        }
        m[val] = i
        // if m[target-val] ！= -1{ // ！=0
            
        // }
    }
    return []int{-1,-1}
}

49. 字母异位词分组

1、计数

用一个map记单词出现的次数做为key。map的设计是关键，key是一个26大小的数组，记录每个字母出现的次数， value用一个string切片，存对应的单词

func groupAnagrams(strs []string) [][]string {

    res := make([][]string, 0)

    m := map[[26]int][]string{}  //key - [26]int, value - []string

    for _, str := range strs {
        count := [26]int{}
        
        for _, c := range str {
            count[c-'a']++
        }

        m[count] = append(m[count], str)
    }

    for _, value := range m {
        res = append(res, value)
    }

    return res
}

2、排序

两个单词经过排序一定一样，基于这个做 —>把排序完的字符串作为map的key即可

注意go对字符串的排序操作，转成byte切片，再根据对切片的排序进行操作

func groupAnagrams(strs []string) [][]string {

    m := map[string][]string{}

    for _, str := range strs {
        s := []byte(str)
        sort.Slice(s, func(i, j int) bool {
            return s[i] < s[j]
        })
        sstr := string(s)
        m[sstr] = append(m[sstr], str)
    }

    res := make([][]string, 0, len(m))	//开结果切片的时候可以根据map的长度给一个初始的cap

    for _, value := range m {
        res = append(res, value)
    }

    return res
    
}