20240326&27&28_HashTablePractise
参考来源：代码随想录，leetcode
242.有效的字母异位词
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
示例 1: 输入: s = “anagram”, t = “nagaram” 输出: true
示例 2: 输入: s = “rat”, t = “car” 输出: false
package Practise.HashTablePractise;
public class No_242 {
/*
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
示例 1: 输入: s = "anagram", t = "nagaram" 输出: true
示例 2: 输入: s = "rat", t = "car" 输出: false
说明: 你可以假设字符串只包含小写字母。
*/
public static void main(String[] args) {
String s = "aee";
String t = "eae";
System.out.println(isAnagram(s,t));
}
public static boolean isAnagram(String s, String t) {
int[] record = new int[26];
for (int i = 0; i < s.length(); i++) {
record[s.charAt(i) - 'a']++;
}
for (int j = 0; j < t.length(); j++) {
record[t.charAt(j) - 'a']--;
}
for (int i : record) {
if (i != 0){
return false;
}
}
return true;
}
}
349. 两个数组的交集
题意：给定两个数组，编写一个函数来计算它们的交集。
package Practise.HashTablePractise;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class No_349 {
/*
给定两个数组 nums1 和 nums2 ，返回它们的交集
。输出结果中的每个元素一定是 唯一 的。我们可以不考虑输出结果的顺序。
*/
public static void main(String[] args) {
int[] num1 = {1,2,2,1};
int[] num2 = {2,2};
System.out.println(Arrays.toString(intersection(num1,num2)));
}
public static int[] intersection(int[] nums1, int[] nums2) {
if (nums1 == null || nums1.length == 0 || null == nums2 || nums2.length == 0){
return new int[0];
}
//存放结果的HashSet和Array
Set<Integer> resSet = new HashSet<>();
int[] res = new int[0];
//定义存放第一个数组的HashSet
Set<Integer> set = new HashSet<>();
//遍历第一个数组,存入HashSet
for (int i : nums1) {
set.add(i);
}
//遍历第二个数组，同时判断有无重复
for (int j : nums2) {
if (set.contains(j)){
resSet.add(j);
}
//保存为数组
res = new int[resSet.size()];
int k = 0;
for (Integer i : resSet) {
res[k++] = i;
}
}
return res;
}
}
第202题. 快乐数
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。
如果 n 是快乐数就返回 True ；不是，则返回 False 。
package Practise.HashTablePractise;
import java.util.HashSet;
import java.util.Set;
public class No_202 {
/*
编写一个算法来判断一个数 n 是不是快乐数。
快乐数定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，
那么这个数就是快乐数。
如果 n 是快乐数就返回 True ；不是，则返回 False 。
示例：
输入：19
输出：true
解释：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1
*/
public static void main(String[] args) {
System.out.println(isHappy(2));
}
public static int getSum(int a) {
int res = 0;
while (a > 0){
int temp = a % 10;
res += temp*temp;
a = a/10;
}
return res;
}
public static boolean isHappy(int n) {
Set<Integer> sumSet = new HashSet<>();
while(n != 1 && !sumSet.contains(n)){
sumSet.add(n) ;
n = getSum(n);
}
return n == 1;
}
}
1. 两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
package Practise.HashTablePractise;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public class No_1 {
/*
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
*/
public static void main(String[] args) {
// int[] nums = {2, 11, 7, 15};
int[] nums = {-1,-2,-3,-4,-5};
int target = -8;
System.out.println(Arrays.toString(twoSum1(nums, target)));
}
public static int[] twoSum1(int[] nums, int target) {//将数组的值当作Map的键是因为键是唯一的
int[] res = new int[2];
if(nums == null || nums.length == 0){
return res;
}
Map<Integer, Integer> map = new HashMap<>();
for(int i = 0; i < nums.length; i++){
int temp = target - nums[i]; // 遍历当前元素，并在map中寻找是否有匹配的key
if(map.containsKey(temp)){
res[1] = i;
res[0] = map.get(temp);
break;
}
map.put(nums[i], i); // 如果没找到匹配对，就把访问过的元素和下标加入到map中
}
return res;
}
public static int[] twoSum(int[] nums, int target) {
// Map<Integer, Integer> resMap = new HashMap<>();
int[] res = new int[2];
int j = 0;
while (j != nums.length - 1) {//暴力法
int sum;
for (int i = j + 1; i < nums.length; i++) {
sum = nums[j] + nums[i];
if (sum == target) {
res[0] = j;
res[1] = i;
break;
}
}
sum = 0;
j++;
}
return res;
}
}
第454题.四数相加II
给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。
package Practise.HashTablePractise;
import java.util.HashMap;
import java.util.Map;
public class No_454 {
/*
给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，
请你计算有多少个元组 (i, j, k, l) 能满足：
0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
*/
public static void main(String[] args) {
int[] num1 = {1, 2};
int[] num2 = {-2, -1};
int[] num3 = {-1, 2};
int[] num4 = {0, 2};
System.out.println(fourSumCount(num1,num2,num3,num4));
}
//getOrDefault(k, v):判断有无该键，若有返回对应值，即使是null；若无返回v
public static int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
int res = 0;
Map<Integer, Integer> map = new HashMap<>();
for (int i : nums1) {
for (int j : nums2) {
int sum = i + j;
map.put(sum, map.getOrDefault(sum, 0) + 1);//统计出现过的次数
}
}for (int k : nums3) {
for (int l : nums4) {
res += map.getOrDefault(0 -k - l, 0);
}
}
return res;
}
}
383. 赎金信
给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。
(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)
package Practise.HashTablePractise;
public class No_383 {
/*
给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，
判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。
如果可以构成，返回 true ；否则返回 false。
(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，
组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)
*/
public static void main(String[] args) {
String ransomNote = "aee";
String magazine = "eae";
System.out.println(canConstruct(ransomNote,magazine));
}
public static boolean canConstruct(String ransomNote, String magazine) {
int[] record = new int[26];
for (int i = 0; i < magazine.length(); i++) {
record[magazine.charAt(i) - 'a']++;
}
for (int j = 0; j < ransomNote.length(); j++) {
record[ransomNote.charAt(j) - 'a']--;
}
for (int i : record) {
if (i < 0){
return false;
}
}
return true;
}
}
第15题. 三数之和
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意： 答案中不可以包含重复的三元组。
示例：
给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]
package Practise.HashTablePractise;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class No_15 {
/*
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，
使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意： 答案中不可以包含重复的三元组。
示例：
给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]
*/
public static void main(String[] args) {
int[] nums = {-1,0,1,2,-1,-4};
System.out.println(threeSum(nums));
}
public static List<List<Integer>> threeSum(int[] nums) {
//存放结果
List<List<Integer>> res = new ArrayList<>();
//先排序，升序
Arrays.sort(nums);
//第一个大于零直接return
if (nums[0] > 0){
return res;
}
for (int i = 0; i < nums.length; i++) {
if (i > 0 && nums[i] == nums[i-1]){continue;}//去重
int left = i + 1;//b = nums[left]
int right = nums.length - 1;//c = nums[nums.length-1]
while (left < right){
int sum = nums[i] + nums[left] + nums[right];
if (sum < 0){
left++;
} else if (sum > 0) {
right--;
}else {
res.add(Arrays.asList(nums[i], nums[left], nums[right]));
while (right > left && nums[right] == nums[right-1]){right--;}//去重
while (right > left && nums[left] == nums[left+1]){left++;}//去重
left++;
right--;
}
}
}
return res;
}
}
第18题. 四数之和
题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
注意：
答案中不可以包含重复的四元组。
示例： 给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。 满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]
package Practise.HashTablePractise;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class No_18 {
/*
题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，
使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
注意：
答案中不可以包含重复的四元组。
示例： 给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。
满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]
*/
public static void main(String[] args) {
int[] nums = {1, 0, -1, 0, -2, 2};
int target = 0;
System.out.println(fourSum(nums,target));
}
public static List<List<Integer>> fourSum(int[] nums, int target) {
List<List<Integer>> res = new ArrayList<>();
Arrays.sort(nums);
for (int i = 0; i < nums.length; i++) {
if (nums[i] > 0 && nums[i] > target){
return res;
}
if(i > 0 && nums[i - 1] == nums[i]){
continue;//对第一个数字去重
}
for (int j = i + 1; j < nums.length; j++) {
if(j > i + 1 && nums[j - 1] == nums[j]){
continue;//对第二个数字去重
}
int left = j + 1;
int right = nums.length - 1;
while (left < right){
int sum = nums[i] + nums[j] + nums[left] + nums[right];
if (sum < target){
left++;
} else if (sum > target) {
right--;
}else {
res.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
while (left < right && nums[left] == nums[left + 1]){left++;}
while (left < right && nums[right] == nums[right - 1]){right--;}
left++;
right--;
}
}
}
}
return res;
}
}
78
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
