力扣——哈希表

最新推荐文章于 2025-05-18 06:00:00 发布

原创最新推荐文章于 2025-05-18 06:00:00 发布 · 263 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#leetcode #算法 #java #数据结构

数据结构与算法同时被 3 个专栏收录

3 篇文章

订阅专栏

力扣

1 篇文章

订阅专栏

哈希

1 篇文章

订阅专栏

本文介绍了如何使用哈希表解决有效字母异位词问题，通过构造数组跟踪字符频率。还展示了如何利用set数据结构找出两个数组的交集和判断快乐数，以及解决两数之和、四数相加、赎金信等经典算法。

力扣——哈希表

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

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
在这里插入图片描述
思路：因为仅含有小写字母，所以通过构造一个长度为26的数组，第一个字符串进行遍历把每个字符出现的次数记录下来，在遍历第二个字符串时，将出现的字符次数通过数组中的次数减1，直到数组中出现小于0的时候就表示字符串1和字符串2中有不一样数量的字符。

class Solution {
    public boolean isAnagram(String s, String t) {
        if(s.length() != t.length()){
            return false;
        }
        int[] table = new int[26];
        for(int i=0;i<s.length();i++){
            table[s.charAt(i) - 'a']++;
        }
        for(int i=0;i<t.length();i++){
            table[t.charAt(i) - 'a']--;
            if(table[t.charAt(i) - 'a'] < 0){
                return false;
            }
        }
        return true;
    }
}

349.两个数组的交集
给定两个数组 nums1 和 nums2 ，返回它们的交集。输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序。
在这里插入图片描述
思路：这道题可以通过set来对第一个数组进行去重，然后再判断第一个数组的集合中是否包含第二个数组中的元素，最后将集合赋值给数组返回即可。

class Solution {
    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<>();
        for (int i : nums1) {
            set1.add(i);
        }
        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;
    }
}

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

「快乐数」定义为：

对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。
如果这个过程结果为 1，那么这个数就是快乐数。
如果 n 是快乐数就返回 true ；不是，则返回 false 。
在这里插入图片描述
思路：首先创建一个set集合来存储平方所产生的所有数字，一旦集合中存在某个数字各个位置的平方和，就代表进入无线循环了，或者直到该数各个位置的平方和为1，退出循环。循环中需要每次都更新下一次需要进行平方的数字。

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> set = new HashSet();
        while(n != 1 && !set.contains(n)){
            set.add(n);
            n = getNext(n);
        }
        return n == 1;
    }
    public int getNext(int n){
        int sum = 0;
        while(n > 0){
            sum = sum + (n % 10)*(n % 10);
            n = n / 10;
        }
        return sum;
    }
}

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

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

你可以按任意顺序返回答案。
在这里插入图片描述
思路：可以通过map来做，用map的key保存数值，value保存数值所在数组中的位置。

public int[] twoSum(int[] nums, int target) {
    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];
        if(map.containsKey(temp)){
            res[1] = i;
            res[0] = map.get(temp);
        }
        map.put(nums[i], i);
    }
    return res;
}

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
在这里插入图片描述
思路：通过map结构来对数组一和数组二的所有可能出现的结果进行计数，key存储的是每一种可能出现的和，value存储的数每种和出现的次数，然后再将数组三和数组四中每个数字和的相反数，去map中寻找是否存在这样的key，如果有就将value进行相加。

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer,Integer> map = new HashMap();
        for(int a : nums1){
            for(int b : nums2){
                map.put(a+b,map.getOrDefault(a+b,0)+1);
            }
        }
        int res = 0;
        for(int a : nums3){
            for(int b : nums4){
                if(map.containsKey(-a-b)){
                    res = res + map.get(-a-b);
                }
            }
        }
        return res;
    }
}

383.赎金信
给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。
在这里插入图片描述

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        if(ransomNote.length() > magazine.length()){
            return false;
        }
        int[] arr = new int[26];
        for(char m : magazine.toCharArray()){
            arr[m - 'a']++;
        }
        for(char r : ransomNote.toCharArray()){
            arr[r - 'a']--;
            if(arr[r - 'a'] < 0){
                return false;
            }
        }
        return true;
    }
}

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

注意：答案中不可以包含重复的三元组。
在这里插入图片描述
思路：首先对数组进行排序，对数组进行遍历，如果遍历道数组中的某一个元素大于0的话，就代表后面的数都是大于0的就不会有和为0的答案存在，退出循环即可。如果遍历到第二个数开始，如果存在和前一个数相同的话就填过当前遍历，进行下一次遍历，目的是为了去重。需要定义三个指针，一个是当前遍历的i,一个是当前遍历元素的下一个元素left，一个是在数组最后的元素right。这样通过left，right指针进行前后寻找，如果遇到相同元素就进行去重，也就是寻找下一个元素。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> list = new ArrayList();
        Arrays.sort(nums);
        for(int i=0;i<nums.length;i++){
            if(nums[i] > 0) break;
            if(i>0 && nums[i] == nums[i-1]) continue;
            int sum = 0;
            int left = i+1,right = nums.length-1;
            while(right > left){
                sum = nums[i] + nums[left] + nums[right];
                if(sum > 0){
                    right--;
                }else if(sum < 0){
                    left++;
                }else{
                    list.add(Arrays.asList(nums[i],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 list;
    }
}

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
你可以按任意顺序返回答案。
在这里插入图片描述
思路和三数之和很像，多了一层循环

class Solution {
    List<List<Integer>> list = new ArrayList();
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        for(int i=0;i<nums.length;i++){
            if(i > 0 && nums[i] == nums[i-1]) continue;

            for(int j=i+1;j<nums.length;j++){
                if(j>i+1 && nums[j] == nums[j-1]) continue;

                int left = j+1,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{
                        list.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 list;
    }
}