哈希表理论基础
1. 哈希表：根据关键码的值而直接进行访问，用来快速判断一个元素是否出现集合里
2. 哈希函数：通过特定编码方式，可以将其他数据格式转化为不同的数值
3. 哈希碰撞：都映射到同一个索引下标的位置
（1）解决一：拉链法是当成链表串在一起
（2）解决二：线性探测法是如果发生冲突，就找下一个空位放信息
4. 常见的三种哈希结构
（1）数组：在哈希值比较小、范围也比较小的时候用数组，如二十六个字母 int[] hash = new int[26]
（2）set集合：如果数值很大、很分散的时候用set
（3）map映射：存储key value对
题目一：有效的字母异位词
1. 题目：给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。也就是组成单词的字母是否一样
2. 思路
（1）因为26个字母范围小、数量小，所以用哈希数组
（2）不用记住字母的ASC||码，直接映射[字母-'a']
public boolean isAnagram(String s, String t) {
int hash[] = new int[26];//创建一个hash数组
for(int i=0;i<s.length();i++){
hash[s.charAt(i)-'a']++;//偏移
}
for(int i=0;i<t.length();i++){
hash[t.charAt(i)-'a']--;
}
for(int i=0;i<26;i++){
if(hash[i]!=0)return false;
}
return true;
}题目二：两个数组的交集
1. 思路
（1）选取哈希结构：因为数值很大很多，所以用HashSet而不是哈希数组
（2）遍历数组一的元素，哈希处理之后放入哈希表中；再用数组二查询，哈希表中是否出现过，把出现过的放入ans中
（3）可以用 return ans.stream().mapToInt(x -> x).toArray(); 将HashSet变为数组
public static int[] intersection(int[] nums1, int[] nums2) {
if(nums1.length==0||nums2.length==0)return new int[0];
Set<Integer> set1 = new HashSet<>();
Set<Integer> ans=new HashSet<>();
for (int i=0;i<nums1.length;i++){
set1.add(nums1[i]);
}
for (int i=0;i<nums2.length;i++){
if (set1.contains(nums2[i]))ans.add(nums2[i]);
}
return ans.stream().mapToInt(x -> x).toArray();
// int[] ans1=new int[ans.size()];
// int j=0;
// for (int i:ans){
// ans1[j++]=i;
// }
// return ans1;
}题目三：是不是快乐数
1. 题目:. - 力扣（LeetCode）
2. 思路
（1）分两个函数写：一个用于计算每个数字的平方的和；另一个用于判断是否有重复
public boolean isHappy(int n) {
Set<Integer> ans=new HashSet<>();
while (!ans.contains(n)){//判断是否有重复
ans.add(n);//放第一个数
if (n==1)return true;
else n=cal(n);
}
return false;
}
public int cal(int n){//计算每个数字平方的和
int sum=0;
while (n>=1){
int temp=(n%10)*(n%10);//不能^2
sum+=temp;
n=n/10;
}
return sum;
}题目四：两数之和
1. 题目：找到两个数之和为target的下标
2. 思路：设置keyvalue对，将数组的<元素值，位置>放入哈希表中，每次查找target-nums[i]
public int[] twoSum(int[] nums, int target) {
HashMap<Integer,Integer> map=new HashMap<>();
int[] ans=new int[2];
for (int i=0;i<nums.length;i++){
if (map.containsKey(target-nums[i])){
ans[0]=i;
ans[1]=map.get(target-nums[i]);
break;
}
map.put(nums[i],i );
}
return ans;
}题目五：四数相加
1. 题目：给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0
2. 思路：
（1）只需要找到有几个四元组就可以，不需要进行去重操作；四个元组是ABCD
（2）将<A+B的值，出现次数>放入map中，遍历C+D，看能不能在map中找到0-(A+B)
（3）可以简化为for(int i: nums1)
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
HashMap<Integer,Integer> map= new HashMap();
int ans=0;
for(int i=0;i<nums1.length;i++){//A,B数组相加放入map中
for(int j=0;j<nums2.length;j++){
map.put(nums1[i]+nums2[j],map.getOrDefault(nums1[i]+nums2[j],0)+1);
}
}
for(int i=0;i<nums3.length;i++){//C,D相加后数组查找有没有对应的相反数
for(int j=0;j<nums4.length;j++){
if(map.containsKey(-nums3[i]-nums4[j]))ans+=map.get(-nums3[i]-nums4[j]);
}
}
return ans;
}题目六：赎金信
1. 题目：给两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。如果可以，返回 true ；否则返回 false 。
2. 思路：因为是26个英文字母，所以用哈希数组；magazine的可以cover ransomnote
3. tips：String用.charAt()；
for(char c : magazine.toCharArray())public boolean canConstruct(String ransomNote, String magazine) {
int[] map=new int[26];
if (ransomNote.length() > magazine.length()) {
return false;
}
for(int i=0;i<magazine.length();i++){
map[magazine.charAt(i)-'a']++;
}
for(int i=0;i<ransomNote.length();i++){
map[ransomNote.charAt(i)-'a']--;
}
for(int i:map){
if(i<0)return false;
}
return true;
}题目七：三数之和
1. 题目：给一个 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组
2. 思路：
（1）哈希法：去重的步骤很多，比较麻烦
（2）双指针法：先将数组排序（因为没有要求返回下标所以可排），有left指针和right指针，如果nums[i]+nums[left]+nums[right]>0则将right--，若<0则将left++
（3）tips：
① 如果排序后数组第一个值>0，则直接返回；continue是进入下一次循环，break是跳出循环
②排序：Arrays.sort(nums)
③更新list：result.add(Arrays.asList(nums[i], nums[left], nums[right]))；Arrays.asList(...)：这是Java中的一个方法，用于将提供的参数（在这个例子中是三个整数）作为一个列表（List）返回
3. 去重：
（1）去重a：nums[i]==nums[i+1]，看的是i和下一个值也就是left是不是相等，也就是abc元组里面不能有重复；nums[i]==nums[i-1]，看的是i和前面的是否重复，这才是答案去重，还要注意i>0，防止nums[-1]
（2）去重bc：若nums[left]==nums[left+1] left++；若nums[right]==nums[right-1] right--，使得都计算最后一个重复的数字
public List<List<Integer>> threeSum(int[] nums) {
//1. 重新sort一下数组，从小到大
List<List<Integer>> ans = new ArrayList<>();
Arrays.sort(nums);
//2. 从数组第一个开始
for(int i=0;i<nums.length;i++){
//3.先判断数组第一个值和i是否有重复
if(nums[i]>0)return ans;
if(i>0 && nums[i]==nums[i-1])continue;
//4. while里面开始遍历b c
int left=i+1;
int right=nums.length-1;//数组中最右的
while(left<right){
if(nums[i]+nums[left]+nums[right]>0){right--;}
else if(nums[i]+nums[left]+nums[right]<0){left++;}
else{//5.更新答案
ans.add(Arrays.asList(nums[i], nums[left], nums[right]));
//6.到倒数第二个重复的数值，对b和c去重
while(left<right && nums[right]==nums[right-1])right--;//if只能做一次
while(left<right && nums[left]==nums[left+1])left++;//while可以做多次
//7.b c到倒数第一个重复的值
right--;
left++;
}
}
}
return ans;
}题目八：四数之和
1. 题目：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
2. 思路
（1）和三数之和的思路是一样，在外层再加一个for循环，对i和k都做剪枝和去重的操作
（2）剪枝(避免做没必要的操作)：
① 对外层k：排序之后不能nums[k]>target，因为target可能是负数，所以加上限制条件nums[k]>0 && nums[k]>target
②对内层i：将nums[k] + nums[i]看作一个整体，nums[k]+nums[i] > target && target >0
（3）去重(答案不重复)：
①对外层k：k>0 && nums[k]==nums[k-1]
②对内层i：i > k+1 && nums[i]==nums[i-1]（因为一开始赋值是 i=k+1）
public List<List<Integer>> fourSum(int[] nums, int target) {
//1.创建答案和排序数组
List<List<Integer>> res = new ArrayList<>();
Arrays.sort(nums);//排序数组
//2.k循环
for(int k=0;k<nums.length;k++){
if(nums[k]>target && target >0)break;//k剪枝，直接返回res
if( k>0 && nums[k]==nums[k-1])continue;//k去重复，大于第一个
for(int i=k+1;i<nums.length;i++){//3.i循环
if (nums[k]+nums[i]>target && nums[k]+nums[i]>0)break;//i剪枝
if (i>k+1 && nums[i-1]==nums[i])continue;//i去重
int left=i+1;
int right=nums.length-1;
while(left<right){//left和right的循环，见三数之和
int sum=nums[i]+nums[left]+nums[right]+nums[k];
if (sum>target)right--;
else if (sum<target)left++;
else{
res.add(Arrays.asList(nums[i],nums[left],nums[right],nums[k]));
while (left<right && nums[left]==nums[left+1])left++;
while (left<right && nums[right]==nums[right-1])right--;
left++;
right--;
}
}
}
}
return res;
}
376
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
