leetcode刷题-哈希表

hahahahanhanhan

已于 2024-03-06 21:06:35 修改

阅读量677

点赞数 13

文章标签：算法 leetcode java

于 2024-03-06 21:03:27 首次发布

本文链接：https://blog.csdn.net/hahahahanhanhan/article/details/136484944

版权

1、有效的字母异位词

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

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

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

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

import java.util.*;
class Solution {
    public boolean isAnagram(String s, String t) {
        int[] a=new int[128];
        // int[] b=new int[128];
        String aa=s;
        if(s.length()<t.length()){
            aa=t;
        }
    
        for(int i=0;i<s.length();i++){
            a[s.charAt(i)]++;
        }
        for(int i=0;i<t.length();i++){
            // b[t.charAt(i)]++;
            a[t.charAt(i)]--;
        }
        for(int i=0;i<128;i++){
            if(a[i]!=0){
                return false;
            }
        }
        // for(int i=0;i<aa.length();i++){
        //     if(b[aa.charAt(i)]!=a[aa.charAt(i)]){
        //         return false;
        //     }
        // }//我這個方法就可以不用遍歷全部的a數組
        return true;

    }
}

2、两个数组的交集

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

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

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {

        //數組大小是固定的
        // int[] res=new int[1000];  
        // for(int i=0;i<nums1.length;i++){
        //     res[nums1[i]]=1;
        // }
        // for(int i=0;i<nums2.length;i++){
        //     if(res[nums2[i]]!=0)//说明存在交集
        //         res[nums2[i]]=2;  
        // }
        // List<Integer> rr=new ArrayList<>();
        // int jj=0;
        
        // for(int i=0;i<1000;i++){
        //     if(res[i]==2)
        //         rr.add(i);
        // }
        // int[] result=new int[rr.size()];
        // for(int num:rr){
        //     result[jj++]=num;
        //  String[] array = (String[])list.toArray(new String[size]);  
        // }
        // return result;

        //第二种方法更通用，不限制数据大小
        Set<Integer> ss=new HashSet<>();
        Set<Integer> res=new HashSet<>();
         for(int i=0;i<nums1.length;i++){
            ss.add(nums1[i]);
        }
         for(int i=0;i<nums2.length;i++){
            if(ss.contains(nums2[i])){
                res.add(nums2[i]);
            }
        }
        int[] result=new int[res.size()];
        int jj=0;
        for(int num:res){
            result[jj++]=num;
        //  String[] array = (String[])list.toArray(new String[size]);  
        }
        return result;
        
       
      


    }
}

3、快乐数

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

import java.util.Set;
import java.util.HashSet;
 // for (int number : sums) {   //使用foreach进行遍历。
		// 	System.out.println(number);
		// }
        // Iterator<Integer> ite =sums.iterator();//使用迭代器遍历
		// while(ite.hasNext())
		// {
		// 	System.out.println(ite.next());
		// }
class Solution {
    public boolean isHappy(int n) {
        //这道题目的关键在于会产生无限循环，所以我们一开始把所有的sum存放到hashset,一旦出现重复sum,
        //就返回false,如果出现1就返回true
        Set<Integer> sums=new HashSet<>();
        String num=""+n;//把数字转化为字符串，方便求每一位数字
       
        //第一种方法，使用字符串来完成数字上每个位的平方计算
        // while(true){
        //      int sum=0;//每次结束一次计算都需要把sum置为0
        //     for(int i=0;i<num.length();i++){
        //         sum+=Math.pow((num.charAt(i)-'0'),2);//'0'对应的10进制为48
        //         System.out.println((num.charAt(i)-'0'));
        //     }
        //     if(sum==1) return true;
        //     if(sums.contains(sum)) return false;
        //     sums.add(sum);
        //     num=""+sum;//每次都需要把sum转化为待计算的字符串
        // }

        //第二种方法，使用数字取余计算每个位置
        while(true){//19
            int sum=0;
            while(n!=0){
                sum+=Math.pow(n%10,2);
                n=n/10;
            }
            if(sum==1) return true;
            if(sums.contains(sum)) return false;
            sums.add(sum);
            n=sum;
        }
       

    }
}

4、两数之和

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

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

示例:

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

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

所以返回 [0, 1]

import java.util.Map;
import java.util.HashMap;
class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] res=new int[2];
        Map<Integer,Integer> map=new HashMap<>();
        //自己想的方法，先把所有数据存入map中，然后把原数组用target减去，
        // 再遍历一次，看看是否有数据在map中出现
        // for(int i=0;i<nums.length;i++){
        //     map.put(nums[i],i);//这里如果有相同数据就会覆盖掉，保存最后一个的值
        //     nums[i]=target-nums[i];
        // }
        // for(int i=0;i<nums.length;i++){
        //     if(map.containsKey(nums[i])&&map.get(nums[i])!=i){//防止1个数字用2次
        //         res[0]=i;
        //         res[1]=map.get(nums[i]);
        //         System.out.println(res[0]+" "+res[1]);
        //         break;
        //     }
        // }

        //改进，其实可以一遍循环解决
        // 在遍历过程中，看看map中是否存在需要的另一半，有就直接返回答案，没有就将当前数据存入map
         for(int i=0;i<nums.length;i++){
            if(map.containsKey(target-nums[i])){
                res[0]=i;
                res[1]=map.get(target-nums[i]);
                break;
            }
            map.put(nums[i],i);
        }

        return res;
       




    }
}

5、四数相加II

给定四个包含整数的数组列表 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]

输出:

解释:

两个元组如下:

(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

import java.util.Map;
import java.util.HashMap;
class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {

        //先把前面2个数组的和统计一下，有几种，每种和出现几次，存入map,key为和，value为和出现的次数
        //然后统计后面2个数组的和,最后再比较2个map是否有相反数，把对应的value相乘
        //Map.getOrDefault(Object key, V defaultValue)
        //用于获取指定键对应的值，如果键不存在，则返回一个默认值
        Map<Integer,Integer> map1=new HashMap<>();
        Map<Integer,Integer> map2=new HashMap<>();
        for(int i=0;i<nums1.length;i++){
            for(int j=0;j<nums2.length;j++){
                int sum=nums1[i]+nums2[j];
                int sum2=nums3[i]+nums4[j];
                map1.put(sum,map1.getOrDefault(sum,0)+1);
                map2.put(sum2,map2.getOrDefault(sum2,0)+1);
            }
        }
        int res=0;
        for(int key:map1.keySet()){
            res+=map1.get(key)* map2.getOrDefault(-key, 0);
        }
         //如果为了减少内存空间，可以只需要一个hashmap,只保存前面2个数组和的统计
        //再逐个遍历后面的2个数组和，判断其相反数-x是否存在
        // for (int i : nums3) {
        //     for (int j : nums4) {
        //         res += map1.getOrDefault(-(i+j), 0);
        //     }
        // }
        return res;
       
    }
}

6、赎金信

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

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

注意：

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

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

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] rr=new int[26];
        int[] mm=new int[26];
        for(int i=0;i<ransomNote.length();i++){
            rr[ransomNote.charAt(i)-'a']++;
        }
        // for(int i=0;i<magazine.length();i++){
        //     mm[magazine.charAt(i)-'a']++;
        // }
        // for(int i=0;i<ransomNote.length();i++){
        //     int n=ransomNote.charAt(i)-'a';
        //     if(rr[n]>mm[n])//说明ransom的字数字数多于magazine
        //         return false;
        // }
        //改进，可以只需要1个数组
        for(int i=0;i<magazine.length();i++){
            rr[magazine.charAt(i)-'a']--;//如果出现正数，说明ransom的字数字数多于magazine
        }
        for(int i:rr){
            if(i>0)return false;
        }
       
        return true;

    }
}

7、三数之和

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

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

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]

import java.util.*;
// Arrays.asList("a","b","c");
// 适用于对象型数据的数组,不使用于基本数据类型的数组
// 将数组与List列表链接起来：当更新其一个时，另一个自动更新

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        //思路：使用双指针，用一个for循环，确定nums[i]，剩下的2个数一个在尾部，一个是i+1
        //开始遍历，如果和>0，说明右指针左移，才能变小，否则left指针右移，和变大
        //这里关键注意去重，nums[i]要保障唯一，确定后，left和right如果也确定，那不能和下一个left right重复
        List<List<Integer>> res=new ArrayList<>();
        Arrays.sort(nums);//先排序,这一步很关键，去重需要
        for(int i=0;i<nums.length;i++){
            if(nums[i]>0)
                return res;
            if (i > 0 && nums[i] == nums[i - 1]) {  // 去重nums[i],需要保证nums[i]是不同的
                continue;
            }
            int left=i+1;
            int right=nums.length-1;
            //for循环已经固定住了nums[i]
            while(left<right){
                if(nums[i]+nums[left]+nums[right]>0) right--;
                else if(nums[i]+nums[left]+nums[right]<0) left++;
                else{
                    res.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    //去重nums[right],需要保证nums[right]是不同的
                    while (right > left && nums[right] == nums[right - 1]) right--;
                    //去重nums[left],需要保证nums[left]是不同的
                    while (right > left && nums[left] == nums[left + 1]) left++;
                    
                    right--; //这一步也是必须的，不然right left一直停留在和为0的三元数组，且循环不能结束
                    left++;
                }
            }
            


        }
        return res;
 

    }
}

8、四数之和

题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：

答案中不可以包含重复的四元组。

示例：给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]

class Solution {
//四数之和，三数之和是一个思路
//都使用双指针法, 三数之和的基础上再套一层for循环
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res=new ArrayList<>();
        Arrays.sort(nums);//排序
        for(int i=0;i<nums.length;i++){
            if(i>0&&nums[i]==nums[i-1])continue;//这里剪纸，保障nums[i]唯一
            for(int j=i+1;j<nums.length;j++){
                int left=j+1;
                int right=nums.length-1;
                if(nums[j]==nums[j-1]&&j>i+1)continue; //保障nums[j]唯一
                //这里注意剪枝j>i+1 不是j>0 
                //因为j的起始位置就是j+1,所以从j+1开始才剪枝
                while(left<right){
                    long sum=(long)nums[i]+nums[j]+nums[left]+nums[right];//这里注意需要long类型，不然会溢出
                    if(sum>target)right--;
                    else if(sum<target) left++;
                    else{//刚好等于target就插入res
                        res.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));
                        System.out.println(res);
                        while(left<right&&nums[right]==nums[right-1]) right--;
                        while(left<right&&nums[left]==nums[left+1]) left++;
                        right--;//换下一个left right组合，反正2个指针任意一个都不能与上个循环组相同
                        left++;
                    }


                }
                
            }
        }
        return res;

    }
}

hahahahanhanhan

关注

13
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
leetcode刷题-哈希表

示例：给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]输出结果中的每个元素一定是唯一的。
复制链接

扫一扫