算法训练第5天|242.有效的字母异位词|349. 两个数组的交集|202. 快乐数|1. 两数之和

LeetCode 242.有效的字母异位词

题目链接：242.有效的字母异位词

题目讲解：代码随想录

题目描述：给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

可以使用哈希表解决该问题， 数组其实就是一个简单哈希表，而且这道题目中字符串只有小写字符，那么就可以定义一个数组，来记录字符串s里字符出现的次数。

func isAnagram(s string, t string) bool {
    record := [26]int{}

    for _, r := range s{
        record[r - rune('a')]++
    }
    for _, r := range t{
        record[r - rune('a')]--
    }

    return record == [26]int{}
}

LeetCode 349. 两个数组的交集

题目链接：349. 两个数组的交集

题目讲解：代码随想录

题目描述：给定两个数组 nums1 和 nums2，返回 它们的交集输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

注意题目特意说明：输出结果中的每个元素一定是唯一的，也就是说输出的结果的去重的， 同时可以不考虑输出结果的顺序。

使用数组的做法：

func intersection(nums1 []int, nums2 []int) []int {
    nums := [1001]int{}

    result := make([]int, 0)

    for _, num1 := range nums1{
        nums[num1]++
    }

    for _, num2 := range nums2{
        if nums[num2] > 0{
            result = append(result, num2)
            nums[num2] = 0 // 去重
        }
    }

    return result
}

如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。

使用Map来做：

func intersection(nums1 []int, nums2 []int) []int {
    set := make(map[int]struct{},0)  // 用map模拟set

    res := make([]int,0)

    for _,v := range nums1{
        if _,ok := set[v]; !ok{ // 如果map中没有对应的值
            set[v] = struct{}{} // 给map设置空结构体
        }
    }

    for _,v := range nums2{
        //如果存在于上一个数组中，则加入结果集，并清空该set值
        if _,ok := set[v]; ok{
            res = append(res,v)

            delete(set, v) // 用来去重
        }
    }

    return res
}

LeetCode 202. 快乐数 

题目链接：202. 快乐数

题目讲解：代码随想录

题目描述：编写一个算法来判断一个数 n 是不是快乐数。

快乐数 定义为：

• 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
• 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到1。
• 如果这个过程 结果为 1，那么这个数就是快乐数。

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

---

判断一个数是否为快乐数，就是计算其每个位置数字平方和是否为1。

如果出现无限循环的情况，则不是快乐数。（这个可以作为一个突破口，当判断一个数是否为快乐数时，如果该数之前访问过，则判断不是快乐数）。

但是在计算过程中，数值是一直变化的，如何判断该数之前访问过是思考的重点。

故使用map，key表示一直变化的快乐数，value表示变化中的快乐数是否访问过。

func isHappy(n int) bool {
    m := make(map[int]bool)

    for n != 1 && !m[n]{ // !m[n]表示，如果m[n] = false，没有重复的情况，进行循环
        n, m[n] = getSum(n), true
    }

    // 跳出循环，说明，n==1 或者 m[n]的值出现重复了（即sum的值重复），sum即n
    return n == 1
}

func getSum(n int)int{
    sum := 0
    for n > 0{
        sum += (n % 10) * (n % 10)
        n = n / 10
    }
    return sum
}

LeetCode 1. 两数之和

题目链接：两数之和

题目讲解：代码随想录

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

最简单的实现方式，就是使用暴力解法，两层for循环。时间复杂度是O()。

但是还有更加好的方案，使用哈希表来解决。当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。

本题，我们不仅要知道元素有没有遍历过，还要知道这个元素对应的下标，故使用map来解决该问题，key表示数组中的元素，value表示的是其对应的下标。

在遍历的过程中，preIndex, ok := m[target - val]表示对应的值是否在之前遍历过，如果遍历过，preIdex返回下标值，ok返回true，否则，ok返回false。

例如target为9，第一个数组值为2，那么就要查看7这个值是否在之前遍历过。如果遍历过，则返回下标。

// 时间复杂度: O(n)
func twoSum(nums []int, target int) []int {
    m := make(map[int]int)
    for index, val := range nums{
        if preIndex, ok := m[target - val]; ok{
            return []int{preIndex, index}
        }else{
            m[val] = index // 将遍历过的元素，添加到map中
        }
    }
    return []int{}
}