【哈希表】

最新推荐文章于 2022-11-18 23:04:13 发布

学海无涯le做舟

最新推荐文章于 2022-11-18 23:04:13 发布

阅读量143

点赞数

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

本文链接：https://blog.csdn.net/qq_40043345/article/details/122296750

版权

算法专栏收录该内容

4 篇文章 0 订阅

订阅专栏

哈希表

理论基础

哈希表有什么作用？

一般哈希表都是用来快速判断一个元素是否出现集合里，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。

哈希函数

把数据元素映射到哈希索引上，用于存储和快速判断元素是否在哈希表中。

哈希碰撞

两个数据元素映射到哈希表的同一索引下引起的冲突，解决方法包括拉链法、线性探测法等；

有效的字母异位词

力扣题目链接(opens new window)

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

示例 1: 输入: s = “anagram”, t = “nagaram” 输出: true

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

说明: 你可以假设字符串只包含小写字母。

思路

暴力解法就是两个for循环,不过多介绍；

换个更优解，利用数组，我们知道英文字符总共就26位，可以利用一个长度为26的数组进行存储，每一位映射字符’a’-‘z’,循环字符串s的时候对应位加一，循环字符串t的时候对应位置减一，最后判断数组是否每一位都为0即可；

class Solution {
    public boolean isAnagram(String s, String t) {
        int[] res = new int[26];

        for(char c:s.toCharArray()){
            res[c-'a'] +=1;
        }
        for(char c :t.toCharArray()){
            res[c-'a'] -=1;
        }
        for(int i : res){
            if(i != 0 ){
                return false;
            }
        }
        return true;
    }
}

两个数组的交集

力扣题目链接(opens new window)

题意：给定两个数组，编写一个函数来计算它们的交集。

349. 两个数组的交集

说明： 输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序。

思路

既然不考虑元素的个数，只考虑是否有交集，那就可以用set进行数据去重和存储，代码如下：

//set常用方法小结：
//add() 添加 remove()删除 isempty()判空 contains()包含元素


class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        if(nums1 == null || nums2 == null || nums1.length == 0 || 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;
    }
}

快乐数

力扣题目链接(opens new window)

编写一个算法来判断一个数 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

思路

这道题目的坑在于可能无限循环，不难发现，如果不是快乐数那他们的和是一定会重复的，因此我们就可以用set进行重复判断从而结束循环，另一点是对每一位数字的操作要熟悉，不然代码很可能出问题；

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

}

两数之和

力扣题目链接

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

思路

这题的主要解决办法是使用map，利用key-value键值对属性，可以快速查找k-v;

class Solution {
    public int[] twoSum(int[] nums, int target) {

        int[] res =new int[2];

        if(nums.length  == 0 || nums == null){
            return res;
        }
        Map<Integer,Integer> map = new HashMap<>();
        for(int i = 0; i<nums.length;i++){
            int tmp = target - nums[i];
            if(map.containsKey(tmp)){
                res[1] = i ;
                res[0] = map.get(tmp);
            }
            map.put(nums[i],i);
        }
        return res;
    }
}

##四数相加II

力扣题目链接(opens new window)

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。

例如:

输入: A = [ 1, 2] B = [-2,-1] C = [-1, 2] D = [ 0, 2] 输出: 2 解释: 两个元组如下:

(0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
(1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0

思路

利用map，key用来存放前两个数组两两相加之和，value用来存放该数出现的次数，再循环得出后两个数组之和，用0减去该数，看map的Key是否包含这个数即可;

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer,Integer> map = new HashMap<>();
        int temp = 0;
        int res = 0;

        for(int i : nums1){
            for(int j : nums2){
                temp = i + j ;
                if(map.containsKey(temp)){
                    map.put(temp,map.get(temp)+1);
                }else{
                    map.put(temp,1);
                }
            }
        }

        for(int i : nums3){
            for(int j : nums4){
                temp = i+j;
                if(map.containsKey(0-temp)){
                    res+= map.get(0-temp);
                }
            }
        }

        return res;
    }
}

赎金信

力扣题目链接(opens new window)

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

注意：

你可以假设两个字符串均只含有小写字母。

canConstruct(“a”, “b”) -> false
canConstruct(“aa”, “ab”) -> false
canConstruct(“aa”, “aab”) -> true

思路

这题和有效的字母异位词很像，题目告知只有小写字母，因此我们可以利用数组对杂志字符串里各个字母出现次数进行存储，再遍历赎金信的字符串，在相应位置减一，判断若小于0说明不够用返回错误，反之返回正确即可；

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        //记录杂志字符串出现的次数
        int[] arr = new int[26];
        int temp;
        for (int i = 0; i < magazine.length(); i++) {
            temp = magazine.charAt(i) - 'a';
            arr[temp]++;
        }
        for (int i = 0; i < ransomNote.length(); i++) {
            temp = ransomNote.charAt(i) - 'a';
            //对于金信中的每一个字符都在数组中查找
            //找到相应位减一，否则找不到返回false
            if (arr[temp] > 0) {
                arr[temp]--;
            } else {
                return false;
            }
        }
        return true;
    }
}