代码随想录03 哈希表

哈希表

哈希表是根据值而直接进行访问的数据结构，数组就是一张哈希表，哈希表中的值就是数组的索引下标，然后通过下标直接访问数组中的元素，如下图所示：

一般哈希表都是用来快速判断一个元素是否出现集合里

Leetcode 242.有效的字母异位词

力扣题目链接(opens new window)

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

示例 1: 输入: s = “anagram”, t = “nagaram” 输出: true

示例 2: 输入: s = “rat”, t = “car” 输出: false

说明: 你可以假设字符串只包含小写字母。

思路

用哈希表存储字母在s中出现次数，在t中每出现一次就减去一次，如果减去时发现没有该字母，或该字母已经减到0，则说明缺少该字母或超出了该字母的出现次数，直接返回false，全部遍历完仍没有问题，则返回true

var isAnagram = function (s, t) {
    if (s.length != t.length){
        return false
    }
    const map = new Map()
    for (let i = 0; i < s.length; i++) {
        if (map.has(s[i])) {
            map.set(s[i], 1 + map.get(s[i]))
        } else {
            map.set(s[i], 1)
        }
    }
    console.log(map)
    for (let i = 0; i < t.length; i++) {
        if (map.get(t[i])) {
            map.set(t[i], map.get(t[i])-1)
        } else {

            console.log(map,i)
            return false
        }
    }

    console.log(map)
    return true
};

Leetcode 349. 两个数组的交集

力扣题目链接(opens new window)

题意：给定两个数组，编写一个函数来计算它们的交集。

说明： 输出结果中的每个元素一定是唯一的。 我们可以不考虑输出结果的顺序。

思路

将nums1数组中出现的元素记录在hashmap中，值设置为1，nums2中的元素如果在hashmap中出现，则设为0（防重复），同时记录到数组中

var intersection = function(nums1, nums2) {
    let result = []
    const map = new Map()
    for (let i = 0; i < nums1.length; i++){
        map.set(nums1[i], 1)
    }

    for (let i = 0; i < nums2.length; i++){
        if (map.get(nums2[i])) {
            map.set(nums2[i], 0)
            result.push(nums2[i])
        }
    }
    return result
};

Leetcode 202. 快乐数

力扣题目链接(opens new window)

编写一个算法来判断一个数 n 是不是快乐数。

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

如果 n 是快乐数就返回 True ；不是，则返回 False 。

示例：

输入：19
输出：true
解释：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1

思路

由于结果可能重复，所以用hashmap记录结果，如果已经有该结果，直接false，如果没有，就一直计算，直到结果为1

var isHappy = function (n) {
    const map = new Map()
    while (!map.has(1)) {
        let stringN = n.toString()
        n = 0
        for (let i = 0; i < stringN.length; i++) {
            n += stringN[i] * stringN[i]
        }
        if (map.has(n)) {
            return false
        } else {
            map.set(n, 1)
        }
    }
    return true
};

Leetcode 1. 两数之和

力扣题目链接(opens new window)

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

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

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

思路

因为每个数值对应的另一个值也是确定的，只需要判断其对应值存不存在，本质还是找存在的问题，可以用hashtable来解决

var twoSum = function (nums, target) {
    const map = new Map()
    for (let i = 0; i < nums.length; i++) {
        if (map.has(nums[i]) && map.get(nums[i]) != i) {
            return [i, map.get(nums[i]) ]
        } else {            
            map.set(target - nums[i], i)
        }
    }
};

Leetcode 454. 四数相加II

力扣题目链接(opens new window)

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。

例如:

输入:

• A = [ 1, 2]
• B = [-2,-1]
• C = [-1, 2]
• D = [ 0, 2]

输出:

2

解释:

两个元组如下:

1. (0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0

思路

分解为两个两数之和，前两个数的所有可能和存入一个map，后两个数的和应该与这个map对应

var fourSumCount = function (nums1, nums2, nums3, nums4) {
    let count = 0
    let len = nums1.length
    const map = new Map()
    for (let i = 0; i < len; i++) {
        for (let j = 0; j < len; j++) {
            if (map.has(nums1[i]+nums2[j])) {
                map.set(nums1[i]+nums2[j], map.get(nums1[i]+nums2[j]) + 1)
            } else {
                map.set(nums1[i]+nums2[j], 1)
            }
        }
    }

    console.log(map)

    for (let i = 0; i < len; i++) {
        for (let j = 0; j < len; j++) {
            if (map.has(0-nums3[i]-nums4[j])) {
                count += map.get(0-nums3[i]-nums4[j])
            }
        }
    }

    return count

};

Leetcode 383. 赎金信

力扣题目链接(opens new window)

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

注意：

你可以假设两个字符串均只含有小写字母。

canConstruct(“a”, “b”) -> false
canConstruct(“aa”, “ab”) -> false
canConstruct(“aa”, “aab”) -> true

var canConstruct = function (ransomNote, magazine) {
    const map = new Map()
    for (let i = 0; i < magazine.length; i++) {
        if (map.has(magazine[i])) {
            map.set(magazine[i], map.get(magazine[i]) + 1)
        } else {
            map.set(magazine[i], 1)
        }
    }

    console.log(map)
    for (let i = 0; i < ransomNote.length; i++) {
        if (map.get(ransomNote[i])) {
            map.set(ransomNote[i], map.get(ransomNote[i]) - 1)
        } else {
            return false
        }
    }

    console.log(map)
    return true
};