目录刷题顺序来自:代码随想录
字母异位词
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;
}