这些力扣题目来源：AI推荐+karshey博主

目录

242.有效的字母异位词（通过）

349.两个数组的交集（通过）

202.快乐数 （通过）

1. 两数之和（通过）

454.四数相加 II（通过）

15. 三数之和（通过）

18.四数之和（通过）

---

242.有效的字母异位词（通过）

242.有效的字母异位词

javascript字符串没有sort方法，需要先转化成数组

两个数组也不能直接比较，必须用join("")方法变成字符串比较

s = "anagram", t = "nagaram"

/**
 * @param {string} s
 * @param {string} t
 * @return {boolean}
 */
var isAnagram = function(s, t) {
    if(s.split("").sort().join("")==t.split("").sort().join("")) return true;
    else return false;
};

console.log(isAnagram(s,t))

349.两个数组的交集（通过）

349.两个数组的交集

集合经常用来去重

取交集有现成的集合方法。此外：还有取并集、差集等其他方法

可以用[...元素]把可以遍历的数据结构转换成数组

nums1 = [1,2,2,1], nums2 = [2,2]
/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var intersection = function(nums1, nums2) {
    let set_1 = new Set(nums1);
    let set_2 = new Set(nums2)
    return [...set_1.intersection(set_2)];
};

console.log(intersection(nums1,nums2));

202.快乐数 （通过）

202.快乐数

把每次的循环计算结果存入一个数组里面 record

出现数字重复的时候可以打断循环

/**
 * @param {number} n
 * @return {boolean}
 */
var isHappy = function(n) {
    let record = []
    while(true){

        if(n==1) return true;

        if(record.indexOf(n)==-1)
            record.push(n);
        else
            return false;

        let temp = [];
        while(n!=0){
            temp.push(n%10);
            n=Math.floor(n/10);
        }
        for(let i=0;i<temp.length;i++){
            n+=temp[i]**2;
        }
    }

};

console.log(isHappy(19));

1. 两数之和（通过）

1. 两数之和

思路：先把和与第一个数的差存入字典（差值作为键、下标作为值）

然后重新遍历数组，如果下标对应的值在字典里面存在，说明现在的下标和存起来键对应的值是答案

注意：现在的下标和存起来对应的值不能相等。否则，证明两个数是同一位置

nums = [1,3,4,2], target = 6

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
    let record={}
    for(let i=0;i<nums.length;i++){
        record[target-nums[i]] = i;
    }
    for(let j=0;j<nums.length;j++){
        if(record[nums[j]] && j!=record[nums[j]]) return [j,record[nums[j]]]
    }
};

console.log(twoSum(nums,target));

454.四数相加 II（通过）

454.四数相加 II

思路：可以先把前面两个数和的相反数用字典存起来。如果是第一次出现数字就是1，如果不是第一次出现就在原基础上加1。

然后用双重循环遍历第三个和第四个数组的和。如果可以在字典里面找到相同的数字，那就把结果加在答案上。

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @param {number[]} nums3
 * @param {number[]} nums4
 * @return {number}
 */
// nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
// nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
nums1 = [-1,-1], nums2 = [-1,1], nums3 = [-1,1], nums4 = [1,-1]

var fourSumCount = function(nums1, nums2, nums3, nums4) {
    let sum12 = {};
    for(let i=0;i<nums1.length;i++){
        for(let j=0;j<nums2.length;j++){
            if(sum12[-(nums1[i]+nums2[j])])
                sum12[-(nums1[i]+nums2[j])]+=1;
            else
                sum12[-(nums1[i]+nums2[j])]=1;
        }
    }
    let count =0;
    for(let i=0;i<nums3.length;i++){
        for(let j=0;j<nums4.length;j++){
            if(sum12[nums3[i]+nums4[j]]) count+=sum12[nums3[i]+nums4[j]];
        }
    }
    return count;
};

console.log(fourSumCount(nums1,nums2,nums3,nums4));

15. 三数之和（通过）

15. 三数之和

思路：数组原来是没有顺序的，但是我们可以重新从小到大排序。这样不影响结果

有了顺序之后，每次固定最左边的值，移动两个指针即可（三数之和小于零时，左指针右移。反之，右指针左移。）

为了确保不重复，如果左指针或右指针下一个数和原来相同，需要多移动几次，直到值不相同。

最左边的值i，也同样可能重复，它可以和前面一个值比较，如果相同，也需要多移动几次。

nums = [-1,0,1,2,-1,-4]

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var threeSum = function(nums) {
    nums.sort((a,b)=>a-b);
    let ans=[];
    for(let i=0;i<nums.length-2;i++){
        
        //去重，nums[i]可能和nums[i+1]一样大
        //有时候需要跳[-1,0,1]重复，有时候不需要跳过[-1,-1,2]不重复
        if(i>0 &&nums[i]==nums[i-1]) continue;

        let left=i+1;
        let right=nums.length-1;
        

        while(left<right){
            sum=nums[i]+nums[left]+nums[right];
            if(sum>0) {
                while(nums[right]==nums[right-1]&&left<right) right--;
                right--;
                continue;
            }
            if(sum<0) {
                while(nums[left]==nums[left+1]&&left<right) left++;
                left++;
                continue;
            }

            if(sum==0){
                ans.push([nums[i],nums[left],nums[right]]);
                while(nums[right]==nums[right-1]&&left<right) right--;
                right--;
                while(nums[left]==nums[left+1]&&left<right) left++;
                left++;
            }
        }
    }
    // for(let i=0;i<ans.length;i++){
    //     console.log(ans[i]);
    // }

    return ans;
};

console.log(threeSum(nums));

18.四数之和（通过）

18.四数之和

和三数之和思路相似，只不过开头固定前面两个数的和，左右指针移动剩下两个部分

nums = [1,0,-1,0,-2,2], target = 0
/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[][]}
 */
var fourSum = function(nums, target) {
    nums.sort((a,b)=>a-b);
    let ans=[]
    for(let i=0;i<nums.length-3;i++){

        if(i>0&&nums[i]==nums[i-1]) continue;

        for(let j=i+1;j<nums.length-2;j++){
            

            if(j>i+1&&nums[j]==nums[j-1]) continue;

            let left=j+1;
            let right=nums.length-1;

            while(left<right){

                let sum=nums[i]+nums[j]+nums[left]+nums[right];
                if(sum<target){
                    while(left<right&&nums[left]==nums[left+1])left++;
                    left++
                    continue
                }
                if(sum>target){
                    while(left<right&&nums[right]==nums[right-1])right--;
                    right--;
                    continue;
                }
                if(sum==target){
                    ans.push([nums[i],nums[j],nums[left],nums[right]]);
                    while(left<right&&nums[left]==nums[left+1])left++;
                    left++
                    while(left<right&&nums[right]==nums[right-1])right--;
                    right--;
                }

            }

        }
    }

    // for(let i=0;i<ans.length;i++)
    //     console.log(ans[i])

    return ans;
};

console.log(fourSum(nums,target));

题外话知识

两个独立的对象，哪怕长得一模一样，也永远不相等。

let a = { name: "Alice" }; let b = { name: "Alice" }; console.log(a === b); // false console.log(a == b); // false

JavaScript 对象比较的是 内存地址，不是内容。