算法之常见哈希表题目

最新推荐文章于 2024-04-14 19:43:21 发布

Mr YiRan

最新推荐文章于 2024-04-14 19:43:21 发布

阅读量1k

点赞数

分类专栏：数据结构与算法文章标签：散列表算法哈希算法

本文链接：https://blog.csdn.net/ChenYiRan123456/article/details/128570110

版权

数据结构与算法专栏收录该内容

19 篇文章 0 订阅

订阅专栏

使用哈希表解决问题时，一般会使用如下三种数据结构

数组
set（集合）
map（映射）

leedcode242. 有效的字母异位词
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
方法：使用数组的方式

class Solution {
    public boolean isAnagram(String s, String t) {
        int [] hash= new int[26];
        for(int i=0;i<s.length();i++){
            hash[s.charAt(i)-'a']++;//这样s.charAt(i)-'a'能保证a的话为hash[0]，b的话为hash[1]，c的话为hash[2]
        }
        //通过数组的减判断数组是不是相同
        for(int i=0;i<t.length();i++){
            hash[t.charAt(i)-'a']--;
        }
        for(int count:hash){
            //如果不为0说明有不同的字母出现，返回false
            if(count!=0){
                return false;
            }
        }
        return true;


    }
}

示例 1:

输入: s = “anagram”, t = “nagaram” 输出: true
示例 2:
输入: s = “rat”, t = “car” 输出: false

leedcode 349. 两个数组的交集
给定两个数组 nums1 和 nums2 ，返回它们的交集。输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序。

示例 1：输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]
示例 2：输入：nums1 => [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4] 解释：[4,9] 也是可通过的

提示：
1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000

方法一，使用哈希表

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        if(nums1==null||nums1.length==0||nums2==null||nums2.length==0){
            return new int[0];
        }
        //新建一个nums1Set的set集合
        Set<Integer> nums1Set=new HashSet<>();
        //新建一个nums2Set的set集合
        Set<Integer> nums2Set=new HashSet<>();
        //将nums1数组里的元素都添加进nums1Set集合，注意nums1Set集合里的元素是不重复的
        for(int i=0;i<nums1.length;i++){
            nums1Set.add(nums1[i]);
        }
        //如果nums1Set集合有和nums2数组相同的元素就添加进入nums2Set集合
        for(int i=0;i<nums2.length;i++){
            if(nums1Set.contains(nums2[i])){
                nums2Set.add(nums2[i]);
            }
        }
       //将nums2Set集合转为数组
        return nums2Set.stream().mapToInt(x -> x).toArray();
    }
}

方法二，使用数组（因为题目限制数组长度在1000以内）

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
      // 存放结果，之所以用set是为了给结果集去重
      Set<Integer> set= new HashSet<>();
      int[] hash=new int[1001];
      for(int i=0;i<hash.length;i++){
          hash[i]=0;
      }
      //将nums1有的元素作为数组的下标进行记录，统一为1
      for(int i=0;i<nums1.length;i++){
          hash[nums1[i]]=1;
      }
      for(int nums:nums2){
          if(hash[nums]==1){
              set.add(nums);
          }
      }
      //将集合转为数组返回
      return set.stream().mapToInt(x->x).toArray();

    }
}

leedcode1. 两数之和
给定一个整数数组 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]

示例 3：

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

如果使用哈希法，那么本题可以使用map，因为使用数组和Set会有局限性。

数组的长度是受限制的，如果元素很少而哈希值太大，则会造成空间的浪费。
set是一个集合，里面放的元素只能时一个Key，而本题不仅要判断y是否存在，而且还要记录y的下标位置，因为要返回两个下标，所以set也不能用。

此时就要选择另一种数据结构——map，它是一种<key,value>的存储结果，可以用Key保存数值，value保存下标。
代码如下：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        //新建一个hashmap用来存储，key保存数值，value保存数值所在的下标
        Map<Integer,Integer> map=new HashMap<>();
        //新建一个res数组用来数组的下标
        int []res=new int[2];
         //遍历当前元素，并在map中寻找是否有匹配的key
        for(int i=0;i<nums.length;i++){
           //result为需要查找的数值
            int result=target-nums[i];
            //如果map包含这个数值
            if(map.containsKey(result)){
               res[1]=i;//第1个元素是也就是目前遍历且匹配的下标
               res[0]=map.get(result);//第0个元素是在前面的时候存储过的下标
               break;
            }
            //存储数值和下标
            map.put(nums[i],i);
        }
        //返回数组
        return res;

    }
}

leedcode202. 快乐数
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为：
对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。
如果这个过程结果为 1，那么这个数就是快乐数。
如果 n 是快乐数就返回 true ；不是，则返回 false 。

示例 1：

输入：n = 19 输出：true
解释： 12 + 92 = 82 82 + 22 = 68 62 + 82 = 100 12 + 02+ 02 = 1

示例 2：

输入：n = 2
输出：false

代码如下：

class Solution {
    //sum值重复说明无限循环（形成了一个闭合），需要判断是否sum值重复使用哈希set
    public boolean isHappy(int n) {
    Set<Integer> set=new HashSet<>();
    //如果n不为1并且set不包含n（说明没重复）才能继续循环
    while(n!=1&&!set.contains(n)){
        //添加进set集合
        set.add(n);
        n=getsqrtSum(n);
    }
    //如果sum的结果不为1，则返回false，否则返回true
    return n==1;
    }
    public int getsqrtSum(int n){
        int res=0;
        while(n>0){
            //取数字后面的位数
            int temp=n%10;
            //res+=temp*temp;
            res+=(int)Math.pow(temp,2);
            //去掉后面位数重新循环取出位数
            n=n/10;
        }
        //此时的res就是求和的值
        return res;
    }
}

leedcode454. 四数相加 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
解释：两个元组如下：

(0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
(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

思路：

定义一个hashmap，key为nums1数组和nums2数组的元素和，value为nums1数组和nums2数组的元素和的出现次数
遍历nums1数组和nums2数组，统计两个数组的元素之和及出现的次数，并放到map中
定义一个变量res用来统计nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0的次数
在遍历nums3数组和nums4数组时，如果0-(c+d)在map中出现，就使用temp统计map中key对应的value也就是两数之和出现的次数。

class Solution {
    //因为要统计 a+b+c+d = 0 出现的次数，可以转换为a+b=0-(c+d)=-c-d
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
    Map<Integer,Integer> map=new HashMap<>();
    int temp=0;//用来记录nums1和nums2数组的元素和
    int res=0;//有来记录返回的数组个数值
    for(int i=0;i<nums1.length;i++){
        for(int j=0;j<nums2.length;j++){
           temp=nums1[i]+nums2[j];
           if(map.containsKey(temp)){
           //如果已经包含则个数要加1
           //例如：a[1]+b[2]=5,a[2]+b[3]=5,a[1]+b[4]=5,然后遇到c[1]+d[2]=-5这样就有3种结果
               map.put(temp,map.get(temp)+1);
           }else{//否则记录出现一次
               map.put(temp,1);
           }
        }
    }
    for(int k=0;k<nums3.length;k++){
        for(int l=0;l<nums4.length;l++){
            temp=-(nums3[k]+nums4[l]);//记录-(c+d)的值
            if(map.containsKey(temp)){//如果刚好有a+b=-(c+d)的值说明四数相加为0，返回个数，但可能还有其他匹配方式，所以res要不断累加
                 res=map.get(temp)+res;
            }
        }
    }
    return res;
    }
}

leedcode383. 赎金信
给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。

示例 1：

输入：ransomNote = “a”, magazine = “b” 输出：false

示例 2：

输入：ransomNote = “aa”, magazine = “ab” 输出：false

示例 3：

输入：ransomNote = “aa”, magazine = “aab” 输出：true

方法一、暴力算法

class Solution {
    //暴力解法,两个for循环遍历查找
    public boolean canConstruct(String ransomNote, String magazine) {
        
  char[] res1=ransomNote.toCharArray();
        char[] res2= magazine.toCharArray();
        boolean flag=false;
        //用ransomNote查找magazine中是否包含
        for(int i=0;i<res1.length;i++){
            flag=false;
            for(int j=0;j<res2.length;j++){
                if(res1[i]==res2[j]){//如果找到了
                    res2[j]='.';//res2[j]确定的话后就要随便给个值，防止重复
                    flag=true;
                    break;
                }
            }
            //如果没有找到就直接返回false，如果不加这一句当你中间已经出现有一个为false了你还继续循环到最后面有个相同的直接返回true
            //这样就会出错，所以要判断一下
            if (!flag) return false;
        }
        return flag;
    }
}

方法二、哈希算法

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        // 定义一个哈希映射数组
        int[] record = new int[26];

        // 遍历
        for(char c : magazine.toCharArray()){
            record[c - 'a'] += 1;
        }

        for(char c : ransomNote.toCharArray()){
            record[c - 'a'] -= 1;
        }
        
        // 如果数组中存在负数，说明ransomNote字符串总存在magazine中没有的字符
        for(int i : record){
            if(i < 0){
                return false;
            }
        }

        return true;
    }
}

leedcode15. 三数之和
给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4] 输出：[[-1,-1,2],[-1,0,1]] 解释： nums[0] +nums[1] + nums[2] = (-1) + 0 + 1 = 0 。 nums[1] + nums[2] + nums[4] = 0+ 1 + (-1) = 0 。 nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1] 输出：[] 解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = [0,0,0] 输出：[[0,0,0]] 解释：唯一可能的三元组和为 0 。

相比于哈希法使用双指针更方便

class Solution {
    //使用双指针法（a+b+c=0）
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result=new ArrayList<>();
        Arrays.sort(nums);//对数组进行升序排序，为了双指针使用方便
        for(int i=0;i<nums.length;i++){
          if(nums[i]>0){//如果第一个是大于0，根据排序规则后，相加不可能为0，所以直接返回result
           return result;
        }
        //去重a
        if(i>0&&nums[i]==nums[i-1]){//i>0时防止nums[i-1]越界，nums[i]==num[i-1]表示前面i已经出现过并且组合过三元组了，如果当前也一样就直接
        //continue换下一个i
            continue;
        }
        //定义双指针
        int left=i+1;
        int right=nums.length-1;
        while(right>left){//这里不right>=left的原因是当right=left就指向同一个数了，我们要的是三个数
        int sum=nums[i]+nums[left]+nums[right];
        if(sum>0){
            right--;
        }else if(sum<0){
            left++;
        }else{//Arrays.asList()将数组转换成List
            result.add(Arrays.asList(nums[i],nums[left],nums[right]));//将满足条件的三元组添加进来
            
            //去重b和c
            while(right>left&&nums[right]==nums[right-1]){
                right--;
            }
            while(right>left&&nums[left]==nums[left+1]){
                left++;
            }
            //向右移动左指针
            left++;
            //向左移动右指针
            right--;
        }
        }
        }
         return result;
    }
}

leedcode18. 四数之和
给你一个由 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]]

本质上在三数之和的基础上再加一层for循环

class Solution {
    //还是双指针法，在三数之和的基础上再加一层for循环
    public List<List<Integer>> fourSum(int[] nums, int target) {
      //定义一个返回的list集合
      List<List<Integer>> result=new ArrayList<>();
      //排序好数组
      Arrays.sort(nums);
      for(int i=0;i<nums.length;i++){
          //这种剪枝是错误的，这道题中的target是任意的，例如-4,-1,0,0target=5,-4是比-5大的，如果按照这种剪枝方法就会漏掉这个结果集
        //    if(nums[i]>target){
        //       return result;
        //   }
          //剪枝一
          if(nums[i]>0&&nums[i]>target){
              return result;
          }
          //去重nums[i]
          if(i>0&&nums[i]==nums[i-1]){
              continue;
          }
          for(int j=i+1;j<nums.length;j++){

              //剪枝二
              if(nums[i]+nums[j]>target&&nums[i]>0){
                  return result;
              }
              //去重nums[j]
              if(j>i+1&&nums[j]==nums[j-1]){
                  continue;
              }
              //定义左指针
              int left=j+1;
              //定义右指针
              int right=nums.length-1;
              //下面和三数之和的判断方法一样
              while(left<right){
                  //nums[k] + nums[i] + nums[left] + nums[right] > target int会溢出
                   long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
                  if(sum>target){
                      right--;
                  }else if(sum<target){
                      left++;
                  }else{
                      result.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));
                      //去重nums[right]
                      while(right>left&&nums[right]==nums[right-1]){
                        right--;
                      }
                      //去重nums[left]
                      while(right>left&&nums[left]==nums[left+1]){
                          left++;
                      }
                      left++;
                      right--;
                  }
              }
          }
      }
      return result;
    }
}

Mr YiRan

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
算法之常见哈希表题目

使用哈希表解决问题时，一般会使用如下三种数据结构 1. 数组 2. set（集合） 3. map（映射）==leedcode242. 有效的字母异位词==给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。方法：使用数组的方式
复制链接

扫一扫