算法打卡第五天 哈希表1 JS 力扣242，349,202,1

242. 有效的字母异位词

/**
 * @param {string} s
 * @param {string} t
 * @return {boolean}
 */
var isAnagram = function(s, t) {
    // 题目说的是如果s和t每个字符出现次数相通，这让我第一反应就是用一个哈希把字符出现字数储存起来
    const hash = new Array(26).fill(0);
    const base = 'a'.charCodeAt();
    for (let i = 0; i <s.length; i++) {
        hash[s.charCodeAt(i) - base] ++; 
    }

    for (let i = 0; i < t.length; i++) {
        hash[t.charCodeAt(i) - base] --; 
    }

    for  (let i = 0; i < hash.length; i++) {
        if (hash[i] !== 0) {
            return false;
        }
    }
    return true;
};

349. 两个数组的交集

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
 // 看到题目第一反应就是排序数组，2个数组各拥有自己的指针
var intersection = function (nums1, nums2) {
    nums1.sort((a, b) => a - b)
    nums2.sort((a, b) => a - b)
    let i = 0, j = 0;
    let ans = [];
    // 排序后使用双指针
    while (i < nums1.length && j < nums2.length) {
        if (nums1[i] < nums2[j]) {
            i++
        } else if (nums1[i] > nums2[j]) {
            j++
        } else {
           // 出现元素相同说明相交
            ans.push(nums1[i]);
            i++;
            j++;
        }

    }
    return [...new Set(ans)]
}
  
  // 第二种方法是刚学习到的，使用set去重长度较长的数组，并且储存数组中的元素
  var intersection = function (nums1, nums2) {
    
    if (nums1.length < nums2.length) {
        let temp = nums2;
        nums2 = nums1;
        nums1 = temp;
    }

    let set1 = new Set(nums1);
    let resSet = new Set();
    // 当循环短的数组时候，一旦发现set1存在相同的元素，说明该元素为交集，用set储存相交的元素，
    // 可以防止重复元素的情况
    for (let i = 0; i < nums2.length; i++) {
        set1.has(nums2[i]) && resSet.add(nums2[i]);
    }
    // 最后将set转为数组
    return Array.from(resSet);
};

相比第一种使用双指针的方法，使用set巧妙的储存，可以减少数组的排序时间成本。

202. 快乐数

/**
 * @param {number} n
 * @return {boolean}
 */
function getNext(n) {
    if (n == 1 || n == 0) return n;
    let res = 0;
    while (n) {
        res += (n % 10) * (n % 10);
        n = parseInt(n / 10);
    }
    return res;
}
// 题目中提到可能会出现无限循环，始终不为1的情况，需要判断是否出现重复的数来避开无限循环的情况
var isHappy = function (n) {
    let set = new Set();
    while (n !== 1 && !set.has(n)) {
        // 使用set储存出现过的数，一旦再次出现相同的数，说明陷入了无限循环
        set.add(n);
        n = getNext(n);
    }
    return n == 1
};

1. 两数之和

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
    // 用map把循环过的数收集起来，用target-nums[i]判断是否存在两数之和为target数
    let map = new Map();
    for (let i = 0; i <nums.length; i++) {
        if (map.has(target - nums[i])) {
            return [map.get(target - nums[i]), i];
        }
        map.set(nums[i], i);
    }
};