算法-哈希表

1. 有效字母的异位词(LeetCode 242)

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

若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
s和t仅包含小写字母

思路：使用大小为26的数组存储单词中每个字母出现的次数

因为题目限制了字符的范围，所以才能用数组作为表

java：str.charAt(pos)返回的是该位置上的字符

class Solution {
    public boolean isAnagram(String s, String t) {
        //字符串s和t仅包含小写字母
        int[] record = new int[26];      
        for(int i = 0; i < s.length(); ++i){
            record[s.charAt(i)-'a']++;
        }
        for(int i = 0; i < t.length(); ++i){
            record[t.charAt(i)-'a']--;
        }
        for(int i = 0; i<26; ++i){
            if(record[i] != 0)   return false;
        }
        return true;
    }
}

2. 两个数组的交集(LeetCode 349)

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

HashSet的常用方法：add(), contains(), remove()
字符串的长度str.length()；数组的长度nums.length
HashSet转为int数组的方式set.stream().mapToInt(x -> x).toArray()

import java.util.HashSet;
class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        HashSet<Integer> record1 = new HashSet<>();
        HashSet<Integer> same = new HashSet<>();
        for(int i = 0; i<nums1.length; ++i){
            record1.add(nums1[i]);
        }
        for(int i = 0; i<nums2.length; ++i){
            if(record1.contains(nums2[i])){
                same.add(nums2[i]);
            }
        }
        //HashSet转化为数组的方式
        return same.stream().mapToInt(x -> x).toArray();
    }
}

3. 快乐数(LeetCode 202)

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

import java.util.HashSet;
import java.util.Set;
class Solution {
    public boolean isHappy(int n) {
        Set<Integer> set = new HashSet<>();
        n = getHappyNumber(n);
        //如果不是快乐数，sum会重复出现
        while(n!=1 && !set.contains(n)){
            set.add(n);
            n = getHappyNumber(n);
        }
        //如果是因为n==1而退出循环，则n为快乐数
        return n == 1;
    }
    public int getHappyNumber(int n){
        int sum = 0;
        while(n!=0){
            sum += (n%10) * (n%10);
            n /= 10;
        }
        return sum;
    }
}

4. 两数之和(LeetCode 1)

题目：给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target的 那两个整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
思路：

Key=nums[i], Value=i;
把前面的元素依次放入map中，不能一下全放（因为有重复键值的可能，即nums[i] == nums[j]）

java：

键值对Key-Value类型的用HashMap存储
HashMap的常用方法有put(key, value), get(key), remove(key), containsKey(), containsValue()

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        int[] array = new int[2];
        for(int i = 0; i<nums.length; ++i){
            int temp = target - nums[i];
            //把前面的元素逐个放到map中
            if(map.containsKey(temp)){
                array[0] = i;
                array[1] = map.get(temp);
                break;
            }
            map.put(nums[i],i);
        }
        return array;
    }
}

5. 四数相加II(LeetCode 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

// O(n^2)
class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        HashMap<Integer,Integer> map = new HashMap<>();
        int n = nums1.length;
        int count = 0;
        // 遍历nums1, nums2
        // 两数相加的结果存到map中,value是出现的次数
        for(int i = 0; i<n; ++i){
            for(int j = 0; j<n; ++j){
                int temp = nums1[i]+nums2[j];
                if(!map.containsKey(temp))  map.put(temp,1);    // 第一次出现value=1
                else map.replace(temp, map.get(temp)+1);        // 多次出现value+1
            }
        }
        //遍历nums3, nums4
        for(int i = 0; i<n; ++i){
            for(int j = 0; j<n; ++j){
                int temp = nums3[i] + nums4[j];
                temp = 0 - temp;
                if(map.containsKey(temp))   count += map.get(temp);
            }
        }
        return count;
    }
}

6. 赎金信(LeetCode 383)

题目：给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。
ransomNote 和 magazine 由小写英文字母组成

思路：因为只有小写英文字母，所以用数组更加节省空间

//数组做法
class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] record = new int[26];
        int i = 0;
        int len1 = ransomNote.length();
        int len2 = magazine.length();
        for(i = 0; i<len2; ++i){
            record[magazine.charAt(i) - 'a']++;
        }
        for(i = 0; i<len1; ++i){
            record[ransomNote.charAt(i) - 'a']--;
        }
        for(i = 0; i<26; ++i){
            if(record[i] < 0)   return false;
        }
        return true;
    }
}

//HashMap做法
class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        HashMap<Character, Integer> map = new HashMap<>();
        // 把magzine中的字母及数量存到map中
        for(int i = 0; i<magazine.length(); ++i){
            char temp = magazine.charAt(i);
            if(!map.containsKey(temp))  map.put(temp, 1);
            else map.replace(temp, map.get(temp)+1);
        }
        // 判断ransomNote需要的字符是否都能找到
        for(int i = 0; i<ransomNote.length(); ++i){
            char temp = ransomNote.charAt(i);
            if(!map.containsKey(temp) || map.get(temp)<=0) return false;
            else map.replace(temp, map.get(temp)-1);
        }
        return true;
    }
}

7. 三数之和(LeetCode 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>> result = new ArrayList<>();
        Arrays.sort(nums);
        int left, right;
        for(int i = 0; i<nums.length; ++i){
            //最小的数大于0，就不需要继续了
            if (nums[i] > 0) return result;
            //对a进行去重操作
            if(i>0 && nums[i] == nums[i-1]) continue;

            left = i + 1;
            right = nums.length - 1;
            while(left < right){
                int temp = nums[i] + nums[left] + nums[right];
                if(temp < 0)        left++;
                else if(temp > 0)   right--;
                else{
                    result.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    // 对b和c进行去重
                    // 找到1个答案了才能去重，否则可能会破坏具有相同元素的答案
                    while(left<right && nums[left] == nums[left+1])     left++;
                    while(left<right && nums[right] == nums[right-1])   right--;
                    left++;
                    right--;
                }
            }
        }
        return result;
    }
}

8. 四数之和(LeetCode 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
你可以按任意顺序返回答案。

思路：

双指针，在三数之和的基础上多加一层循环
去重的时候注意i，j的条件；比较是和之前自己的取值比，即nums[i]与nums[i-1]
本题要求的是总和等于target，与总和为0的要求不同

// O(n^3)
class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        List<List<Integer>> result = new ArrayList<>();
        int i, j;
        int left, right;
        for(i = 0; i<nums.length; ++i){
            //剪枝
            if(nums[i] > 0 && nums[i] > target) return result;
            //a去重
            if(i > 0 && nums[i] == nums[i-1]) continue;
            for(j = i+1; j<nums.length; ++j){
                //b去重
                if(j>i+1 && nums[j] == nums[j-1]) continue;

                left = j + 1;
                right = nums.length - 1;

                while(left < right){
                // 总和用long类型存储，防止溢出
                long temp = nums[i] + nums[j] + nums[left] + nums[right];
                if(temp < target)        left++;
                else if(temp > target)   right--;
                else{
                    result.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                    // 对c和d进行去重
                    // 找到1个答案了才能去重，否则可能会破坏具有相同元素的答案
                    while(left<right && nums[left] == nums[left+1])     left++;
                    while(left<right && nums[right] == nums[right-1])   right--;
                    left++;
                    right--;
                    }
                }
            }
        }
        return result;
    }
}

posted @ 2024-02-21 13:43 Frank23 阅读(4) 评论(0) 编辑收藏举报

刷新页面返回顶部

Keep moving.