Day4 - 哈希表篇

242. 有效的字母异位词

给定两个字符串 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']++;
        }

        for(int i = 0; i < t.length(); i++){
            hash[t.charAt(i)- 'a']--;
        }

        for(int i = 0; i < 26; i++){
            if(hash[i] != 0){//判断t相比于s是否多/少字母
                return false;
            }
        }
        return true;
    }
}

202. 快乐数

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

「快乐数」 定义为：

• 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
• 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
• 如果这个过程 结果为 1，那么这个数就是快乐数。

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

class Solution {
    public int getSum(int n){
        int sum = 0;
        while(n > 0){
            sum += (n % 10) * (n % 10); 
            n = n / 10;
        }
        return sum;
    }

    public boolean isHappy(int n) {
        Set<Integer> data = new HashSet<>();
        while ( n != 1 && !data.contains(n)){
            data.add(n);
            n = getSum(n);
        }
        return n == 1;
        
    }
    
}

1. 两数之和

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

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

你可以按任意顺序返回答案。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        int res[] = new int[2];
        if(nums == null || nums.length == 0){
            res = null;
        }
        for(int i = 0; i < nums.length; i++){
            //定义要查询的元素
            int temp = target - nums[i];
            if(map.containsKey(temp)){
                res[0] = i;
                res[1] = map.get(temp);
                break;//跳出循环，返回结果
            }
            map.put(nums[i],i);
        }
        return res;
    }
}

454. 四数相加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

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        //将nums1+nums2的值，以及该值出现的次数存入map
        Map<Integer, Integer> map = new HashMap<>();
        //定义元组个数
        int count = 0;

        //遍历nums1,nums2的值
        for(int i = 0; i < nums1.length; i++){
            for(int j = 0; j < nums2.length; j++){
                int sum = nums1[i] + nums2[j];
                map.put(sum,map.getOrDefault(sum,0)+1);
            }
        }
        //遍历nums3,nums4的值
        for(int i = 0; i < nums3.length; i++){
            for(int j = 0; j < nums4.length; j++){
                int target = 0 - (nums3[i] + nums4[j]);
                count += map.getOrDefault(target,0);
                // if(map.containsKey(target)){
                //     count += map.getOrDefault(target,0);
                // }
            }
        }
        return count;
    }
}

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 hash[] = new int[26];//定义哈希数组
        for(int i = 0; i < ransomNote.length(); i++){
            hash[ransomNote.charAt(i)-'a']++;
        }
        for(int i = 0; i < magazine.length(); i++){
            hash[magazine.charAt(i)-'a']--;
        }

        for(int i = 0; i < 26; i++){
            if(hash[i] > 0){
                return false;
            }
        }
        return true;
        
    }
}

15. 三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> reslut = new ArrayList<>();
        //先排序数组
        Arrays.sort(nums);

        for(int i = 0; i < nums.length; i++){
            //先判断第一个数是否大于0，大于0则无需再相加
            if(nums[i] > 0) {
                return reslut;
            }
            //对第一个相加元素去重
            if(i > 0 && nums[i] == nums[i-1]){
                continue;
            }
            int left = i + 1;
            int right = nums.length - 1;

            //用双指针法判断
            while(right > left){
                if((nums[i] + nums[left] + nums[right]) >0){
                    right--;
                } else if((nums[i] + nums[left] + nums[right]) < 0){
                    left++;
                } else {
                    reslut.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++;
                    }

                    right--;
                    left++;
                }
            }
        }
        return reslut;
    }
}