哈希表算法小结(JS)

57 阅读3分钟

哈希表算法汇总

有效的字母异位词

leetcode.cn/problems/va…

/**
 * @param {string} s
 * @param {string} t
 * @return {boolean}
 */
var isAnagram = function (s, t) {
  const sMap = new Map()
  for (let i = 0; i < s.length; i++) {
    sMap.set(s[i], sMap.get(s[i]) + 1 || 1)
  }
  for (let i = 0; i < t.length; i++) {
    if (!sMap.has(t[i])) return false
    sMap.set(t[i], sMap.get(t[i]) - 1)
    if (sMap.get(t[i]) === 0) sMap.delete(t[i])
  }
  return sMap.size === 0
}

383. 赎金信

leetcode.cn/problems/ra…

/**
 * @param {string} ransomNote
 * @param {string} magazine
 * @return {boolean}
 */
var canConstruct = function (ransomNote, magazine) {
  const mMap = new Map()
  for (let i = 0; i < magazine.length; i++) {
    mMap.set(magazine[i], mMap.get(magazine[i]) + 1 || 1)
  }
  for (let i = 0; i < ransomNote.length; i++) {
    if (!mMap.has(ransomNote[i])) return false
    mMap.set(ransomNote[i], mMap.get(ransomNote[i]) - 1)
    if (mMap.get(ransomNote[i]) === 0) mMap.delete(ransomNote[i])
  }
  return true
}

49.字母异位词分组

leetcode.cn/problems/gr…

/**
 * @param {string[]} strs
 * @return {string[][]}
 */
var groupAnagrams = function (strs) {
  // 排序+map
  const map = new Map()
  for (let i = 0; i < strs.length; i++) {
    const key = strs[i].split('').sort().join('')
    if (!map.has(key)) {
      map.set(key, [strs[i]])
    } else {
      map.set(key, [...map.get(key), strs[i]])
    }
  }
  return Array.from(map.values())
}

438. 找到字符串中所有字母异位词

leetcode.cn/problems/fi…

/**
 * @param {string} s
 * @param {string} p
 * @return {number[]}
 */
var findAnagrams = function (s, p) {
  const res = [],
    map = new Map()
  let slow = 0,
    fast = 0
  for (let i = 0; i < p.length; i++) {
    map.set(p[i], map.get(p[i]) + 1 || 1)
  }
  let needCnt = map.size
  while (fast < s.length) {
    if (map.has(s[fast])) {
      map.set(s[fast], map.get(s[fast]) - 1)
    }
    if (map.get(s[fast]) === 0) needCnt--
    slow = fast - p.length
    if (map.has(s[slow])) {
      map.set(s[slow], map.get(s[slow]) + 1)
      if (map.get(s[slow]) === 1) needCnt++
    }
    if (needCnt === 0) {
      res.push(slow + 1)
    }
    fast++
  }
  return res
}

349. 两个数组的交集

leetcode.cn/problems/in…

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var intersection = function (nums1, nums2) {
  const set = new Set()
  nums1.forEach((num1) => {
    if (nums2.includes(num1)) set.add(num1)
  })
  return Array.from(set)
}

两个数组的交集 II

leetcode.cn/problems/in…

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var intersect = function (nums1, nums2) {
  const res = []
  for (let i = 0; i < nums1.length; i++) {
    if (nums2.includes(nums1[i])) {
      res.push(nums1[i])
      nums2.splice(nums2.indexOf(nums1[i]), 1)
    }
  }
  return res
}

第 202 题. 快乐数

leetcode.cn/problems/ha…

/*
 * @lc app=leetcode.cn id=202 lang=javascript
 *
 * [202] 快乐数
 */

// @lc code=start
/**
 * @param {number} n
 * @return {boolean}
 */
var isHappy = function (n) {
  const set = new Set()
  while (true) {
    if (set.has(n)) return false
    const sum = n
      .toString()
      .split('')
      .reduce((pre, cur) => pre + Number(cur) ** 2, 0)
    if (sum === 1) return true
    set.add(n)
    n = sum
  }
}
// @lc code=end

两数之和

leetcode.cn/problems/tw…

/*
 * @lc app=leetcode.cn id=1 lang=javascript
 *
 * [1] 两数之和
 */

// @lc code=start
/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function (nums, target) {
  const map = new Map()
  for (let i = 0; i < nums.length; i++) {
    if (map.has(target - nums[i])) {
      return [i, map.get(target - nums[i])]
    }
    map.set(nums[i], i)
  }
}
// @lc code=end

454. 四数相加 II

leetcode.cn/problems/4s…

/*
 * @lc app=leetcode.cn id=454 lang=javascript
 *
 * [454] 四数相加 II
 */

// @lc code=start
/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @param {number[]} nums3
 * @param {number[]} nums4
 * @return {number}
 */
var fourSumCount = function (nums1, nums2, nums3, nums4) {
  let res = 0
  const map = new Map()
  for (let i = 0; i < nums1.length; i++) {
    for (let j = 0; j < nums2.length; j++) {
      const sum = nums1[i] + nums2[j]
      map.set(sum, map.get(sum) + 1 || 1)
    }
  }
  for (let i = 0; i < nums3.length; i++) {
    for (let j = 0; j < nums4.length; j++) {
      const sum = nums3[i] + nums4[j]
      if (map.has(-sum)) {
        res += map.get(-sum)
      }
    }
  }
  return res
}
// @lc code=end

三数之和

leetcode.cn/problems/3s…

/*
 * @lc app=leetcode.cn id=15 lang=javascript
 *
 * [15] 三数之和
 */

// @lc code=start
/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var threeSum = function (nums) {
  nums.sort((a, b) => a - b)
  const res = []
  for (let i = 0; i < nums.length; i++) {
    if (i !== 0 && nums[i] === nums[i - 1]) {
      continue
    }
    if (nums[i] > 0) {
      break
    }
    let left = i + 1,
      right = nums.length - 1
    while (left < right) {
      const sum = nums[i] + nums[left] + nums[right]
      if (sum === 0) {
        res.push([nums[i], nums[left], nums[right]])
        while (nums[left] === nums[left + 1]) {
          left++
        }
        while (nums[right] === nums[right - 1]) {
          right--
        }
        left++
        right--
      } else if (sum > 0) {
        right--
      } else {
        left++
      }
    }
  }
  return res
}
// @lc code=end

四数之和

leetcode.cn/problems/4s…

/*
 * @lc app=leetcode.cn id=18 lang=javascript
 *
 * [18] 四数之和
 */

// @lc code=start
/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[][]}
 */
var fourSum = function (nums, target) {
  nums.sort((a, b) => a - b)
  const res = []
  for (let i = 0; i < nums.length; i++) {
    if (i !== 0 && nums[i] === nums[i - 1]) continue
    for (let j = i + 1; j < nums.length; j++) {
      if (j !== i + 1 && nums[j] === nums[j - 1]) continue
      let left = j + 1,
        right = nums.length - 1
      while (left < right) {
        const sum = nums[i] + nums[j] + nums[left] + nums[right]
        if (sum > target) {
          right--
        } else if (sum < target) {
          left++
        } else {
          res.push([nums[i], nums[j], nums[left], nums[right]])
          while (nums[left] === nums[left + 1]) left++
          while (nums[right - 1] === nums[right]) right--
          left++
          right--
        }
      }
    }
  }
  return res
}
// @lc code=end