代码随想录第6天 | 242. 有效的字母异位词、349. 两个数组的交集、202.快乐数、1. 两数之和

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

242. 有效的字母异位词

1. 用数组操作：

可以定义一个result数组来记录字符串s上字符出现的次数，在数组中的位置就等于该字符减去’a’的ASCII码的相对数值，总大小为26。

在检查字符串t中是否出现这些字符时，同样在遍历字符串t的时候，对t中出现的字符映射哈希表索引上的数值再做-1的操作。

最后，result数组如果有的元素不为零0，说明字符串s和t一定是谁多了字符或者谁少了字符，return false。如果全为0说明，全部匹配上则 return true。

/**
 * @param {string} s
 * @param {string} t
 * @return {boolean}
 */
var isAnagram = function(s, t) {
    if(s.length !== t.length) return false;
    let arr = new Array(26).fill(0);
    let base = 'a'.charCodeAt();
    for(const i of s){
        arr[i.charCodeAt() - base]++;
    }
    for(const i of t){
        if(arr[i.charCodeAt() - base] === 0) return false;
        arr[i.charCodeAt() - base]--;
    }
    return true;
};

2. 用Map操作：

用Map上的key表示字符，value表示该字符出现的次数，每次该字符出现一次就进行value+1的操作。

/**
 * @param {string} s
 * @param {string} t
 * @return {boolean}
 */
var isAnagram = function(s, t) {
    if(s.length !== t.length) return false;
    let char_count = new Map();
    for(const item of s){
        char_count.set(item, (char_count.get(item) || 0) + 1);
    }
    for(const item of t){
        if(!char_count.get(item)) return false;
        char_count.set(item, char_count.get(item) - 1);
    }
    return true;
};

349. 两个数组的交集

本题可以用Set结构，因为Set中键是唯一的不重复的，可以先将较大的数组转为Set后，再和另一个数组遍历元素进行比较，如果该元素有相等的键与其对应，那么就将这个元素保存起来最后返回。

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var intersection = function (nums1, nums2) {
    // 根据数组大小交换操作的数组
    if(nums1.length < nums2.length) {
        const _ = nums1;
        nums1 = nums2;
        nums2 = _;
    }
    const nums1Set = new Set(nums1);
    const resSet = new Set();
    // 循环 比 迭代器快
    for(let i = nums2.length - 1; i >= 0; i--) {
        nums1Set.has(nums2[i]) && resSet.add(nums2[i]);
    }
    return Array.from(resSet)
};

202.快乐数

要点：题目中说了会 无限循环，那么也就是说求和的过程中，sum会重复出现，如果sum重复出现了那么就不可能是快乐数了，否则一直找到sum为1为止。

1. 使用Map

/**
 * @param {number} n
 * @return {boolean}
 */
var isHappy = function (n) {
    let m = new Map();
    const getSum = (num) => {
        let sum = 0;
        while (num) {
            sum += (num % 10) ** 2;
            num = Math.floor(num / 10);
        }
        return sum;
    }
    while (true) {
        if(m.has(n)) return false;
        if(n === 1) return true;
        m.set(n, 1);
        n = getSum(n);
    }
};

2. 使用Set

/**
 * @param {number} n
 * @return {boolean}
 */

var getSum = function (n) {
    let sum = 0;
    while (n) {
        sum += (n % 10) ** 2;
        n = Math.floor(n / 10);
    }
    return sum;
}
var isHappy = function (n) {
    let set = new Set();
    while (n !== 1 && !set.has(n)) {
        set.add(n);
        n = getSum(n);
    }
    return n === 1;
};

1. 两数之和

首先可以定义一个Map，其键值分别对应数组中的元素和索引。

如何判断两数和等于target：遍历数组的过程中，用target减去该元素，就是需要在map中寻找的另外一个数，如果map中存在就直接返回两数下标，如果没有找到就把当前元素的值和索引存入map中再继续遍历。

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

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function (nums, target) {
    let hash = {};
    for (let i = 0; i < nums.length; i++) {  // 遍历当前元素，并在map中寻找是否有匹配的key
        if (hash[target - nums[i]] !== undefined) {
            return [i, hash[target - nums[i]]];
        }
        hash[nums[i]] = i;   // 如果没找到匹配对，就把访问过的元素和下标加入到map中
    }
    return [];
};