刷题顺序来自：代码随想录

• 字母异位词
  • 242. 有效的字母异位词
• 赎金信
  • 383. 赎金信
• 两个数组的交集
  • 349. 两个数组的交集
  • 350. 两个数组的交集 II
• 快乐数
  • 202. 快乐数
• 两数之和
  • 1. 两数之和
  • 454. 四数相加 II
• 三数之和
  • 15. 三数之和
  • 18. 四数之和

字母异位词

242. 有效的字母异位词

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

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

• 1 <= s.length, t.length <= 5 * 104
• s 和 t 仅包含小写字母

public boolean isAnagram(String s, String t) {
    if(s.length() != t.length()) {
        return false;
    }

    int[] sFreq = freq(s);
    int[] tFreq = freq(t);

    for(int i = 0; i < 26; i++) {
        if(sFreq[i] != tFreq[i]) {
            return false;
        }
    }

    return true;
}

public int[] freq(String s) {
    int[] freq = new int[26];  // 存储每个字母的出现频率

    for(int i = 0; i < s.length(); i++) {
        char ch = s.charAt(i);
        freq[ch-'a']++;
    }

    return freq;
}

赎金信

383. 赎金信

给你一个赎金信 (ransomNote) 字符串和一个杂志(magazine)字符串，判断 ransomNote 能不能由 magazines 里面的字符构成。

• magazine 中的每个字符只能在 ransomNote 中使用一次。
• ransomNote 和 magazine 由小写英文字母组成

示例 1:

输入：ransomNote = "aa", magazine = "ab"
输出：false

示例 2:

输入：ransomNote = "aa", magazine = "aab"
输出：true

public boolean canConstruct(String ransomNote, String magazine) {
    // 记录字母出现频率
    int[] rFreq = getFreq(ransomNote), mFreq = getFreq(magazine);

    for(int i = 0; i < 26; i++) {
        if(rFreq[i] > mFreq[i]) {
            return false;
        }
    }
    return true;
}

public int[] getFreq(String s) {
    int[] freq = new int[26];

    for(int i = 0; i < s.length(); i++) {
        freq[s.charAt(i) - 'a']++;
    }

    return freq;
}

两个数组的交集

349. 两个数组的交集

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

示例 1:

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例 2:

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]

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

使用HashSet存储数组中所出现的数字。

public int[] intersection(int[] nums1, int[] nums2) {
    if (nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0) {
        return new int[0];
    }
    Set<Integer> set1 = new HashSet<>();
    Set<Integer> resSet = new HashSet<>();
    //遍历数组1
    for (int i : nums1) {
        set1.add(i);
    }
    //遍历数组2的过程中判断哈希表中是否存在该元素
    for (int i : nums2) {
        if (set1.contains(i)) {
            resSet.add(i);
        }
    }
    int[] resArr = new int[resSet.size()];
    int index = 0;
    //将结果几何转为数组
    for (int i : resSet) {
        resArr[index++] = i;
    }
    return resArr;
}

350. 两个数组的交集 II

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

示例 1:

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]

示例 2:

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[4,9]

• 输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致。
• 我们可以不考虑输出结果的顺序。

快乐数

202. 快乐数

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

「快乐数」定义为：

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

// 当对数字不断操作的过程中产生重复时，证明它会陷入无限循环，不是快乐数
public boolean isHappy(int n) {
    HashSet<Integer> set = new HashSet<>();  // 保存历史操作

    while(n != 1) {
        n = happy(n);
        if(set.contains(n)) {
            return false;
        }
        else {
            set.add(n);
        }
    }

    return true;
}

public int happy(int n) {
    int result = 0;
    while(n != 0) {
        int remainder = n % 10;
        result += remainder * remainder;
        n = n / 10;
    }
    return result;
}

两数之和

1. 两数之和

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1:

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2:

输入：nums = [3,2,4], target = 6
输出：[1,2]

public int[] twoSum(int[] nums, int target) {
    HashMap<Integer, Integer> map = new HashMap<>();  // 保存数组索引
    int[] result = new int[2];

    for(int i = 0; i < nums.length; i++) {
        // 在之前是否一个数字与当前数字相加和为target
 		// 如果有，则返回这两个数字的索引		       
        if(map.containsKey(target - nums[i])) {
            result[0] = map.get(target - nums[i]);
            result[1] = i;
            return result;
        }
        map.put(nums[i], i);
    }
    return null;
}

454. 四数相加 II

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

• 0 <= i, j, k, l < n
• nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

示例 1:

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

示例 2:

输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出：1

与上一题的方法类似，由2个数组变为4个之后，需要以2个数组为一个单位构建一个HashMap。

public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
    if(nums1.length == 0) return 0;

    HashMap<Integer, Integer> map = new HashMap<>();

    // 记录数组1和2元素相加出现的次数
    for(int i = 0; i < nums1.length; i++) {
        for(int j = 0; j < nums2.length; j++) {
            map.put(nums1[i]+nums2[j], map.getOrDefault(nums1[i]+nums2[j], 0) + 1);
        }
    }

    int count = 0;
    for(int i = 0; i < nums3.length; i++) {
        for(int j = 0; j < nums4.length; j++) {
            count += map.getOrDefault(-nums3[i]-nums4[j], 0);
        }
    }

    return count;
}

三数之和

15. 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例 1:

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]

示例 2:

输入：nums = [0]
输出：[]

首先将数组排序，大循环从左到右每次移动一格，在每次大循环中，通过双指针寻找三元组。注意两处去重的代码。

public List<List<Integer>> threeSum(int[] nums) {
    if(nums.length < 3) return new ArrayList();

    Arrays.sort(nums);  // 排序
    List<List<Integer>> res = new ArrayList<>();

    for(int i = 0; i < nums.length - 2; i++) {
        // 去重
        if(i >= 1 && nums[i] == nums[i-1]) {
            continue;
        }

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

        while(left < right) {
            if(nums[i] + nums[left] + nums[right] == 0) {
                ArrayList<Integer> list = new ArrayList<>();
                list.add(nums[i]);
                list.add(nums[left]);
                list.add(nums[right]);
                res.add(list);
				
                // 去重
                while(left < right && nums[left] == nums[++left]) { }
            }
            else if(nums[i] + nums[left] + nums[right] < 0) {
                left++;
            }
            else {
                right--;
            }
        }
    }

    return res;
}

18. 四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

• 0 <= a, b, c, d < n
• a、b、c 和 d 互不相同
• nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案 。

示例 1:

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例 2:

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

与上一题类似，需要有双重循环+双指针，多出来的一次循环也要去重。

public List<List<Integer>> fourSum(int[] nums, int target) {
    if(nums.length < 4) return new ArrayList();

    ArrayList<List<Integer>> res = new ArrayList<>();
    Arrays.sort(nums);

    for(int i = 0; i < nums.length - 3; i++) {
        if(i > 0 && nums[i] == nums[i-1]) continue;  // 去重
        for(int j = i + 1; j < nums.length - 2; j++) {
            if(j > i + 1 && nums[j] == nums[j-1]) continue;  // 去重  
            int left = j + 1, right = nums.length - 1;

            while(left < right) {
                if(nums[i] + nums[j] + nums[left] + nums[right] == target) {
                    ArrayList<Integer> list = new ArrayList<>();
                    list.add(nums[i]);
                    list.add(nums[j]);
                    list.add(nums[left]);
                    list.add(nums[right]);
                    res.add(list);

                    while(left < right && nums[left] == nums[++left]) {}  // 去重
                }
                else if(nums[i] + nums[j] + nums[left] + nums[right] < target) {
                    left++;
                }
                else {
                    right--;
                }
            }

        }
    }

    return res;
}