Day06 哈希表part02

nagireo

已于 2024-01-22 00:15:22 修改

阅读量944

点赞数 18

文章标签：数据结构算法

于 2024-01-19 23:13:43 首次发布

本文链接：https://blog.csdn.net/nagireo/article/details/135699966

版权

1. 两数之和

视频链接：梦开始的地方，Leetcode：1.两数之和，学透哈希表，map使用有技巧！_哔哩哔哩_bilibili

文章链接：代码随想录

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

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

示例:

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

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

所以返回 [0, 1]

本题需要用到map集合。

Map集合基础知识

1.键（key），值（value）

2.键可以重复，值不行

常见方法

put(k,v) 添加元素

remove(k) 删除元素

containsKey(k) 判断是否包含指定键（返回boolean）

containsValue(v) 同上

size（）长度

本题思路

首先判断nums是否为空否则会引发空指针异常。再判断长度是否大于2。用一个hashmap集合record保存遍历过的数值和索引。再用一个数组result保存结果值。用一个for循环遍历数组，如果在record找到了target-nums[i]（containsKey）,保存到数组后返回。如果没找到，返回空数组。

代码

class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer,Integer> record=new HashMap();
        int result[]=new int[2];
        if(nums==null||nums.length<2)
        return result;
        for(int i=0;i<nums.length;i++){
            if(record.containsKey(target-nums[i])){
                result[0]=i;
                result[1]=record.get(target-nums[i]);
                return result;
            }else{
                record.put(nums[i],i);
            }

        }
return result;
    }
}

第454题.四数相加II

视频链接：学透哈希表，map使用有技巧！LeetCode：454.四数相加II_哔哩哔哩_bilibili

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

不常见方法

getOrDefault(K,V) 如果有K就返回K所对的v，如果K不存在则返回V

思路

先遍历前两个数组再遍历后两个数组。map集合用来保存1，2数组中元素两两相加的和的结果和次数，然后第二个双层for用于查找有几个3，4加起来的元素的负数等不等于map集合里的数。有则返回次数，无返回0，总数用res保存。

代码

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int res=0;
        HashMap<Integer,Integer> map=new HashMap();
        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);//如果map中存在sum则返回所对的值，如果没有，则返回0

            
            }
        }
        //前两个for循环用于求a+b有几种值（k）出现了几次（j）
        for(int i:nums3){
            for(int j:nums4){
                int sum=i+j;

                
             res+=map.getOrDefault(-sum,0);
                }
            
        }
        return res;
    }
}

第15题. 三数之和

视频链接：梦破碎的地方！| LeetCode：15.三数之和_哔哩哔哩_bilibili

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

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

示例：

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

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

不常见方法

Array.asList(数组/数值); 数组转集合，也可以直接传值

思路

基本的思路就是利用for循环的i，加上左指针和右指针遍历数组。注意数组首先要排序。因为是利用和的大小移动指针的。三个指针都要去重。首先当i对应的元素大于0时直接返回，因为后面加起来不可能为0.然后相邻两个数一样的时候跳过。最后利用while循环，以left<right为条件，和>0就r指针向左移动，反之。最后r和l先判断前后有无相同数字，有就用while移动，无就照常移动。

代码

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        int left,right;
        List<List<Integer>>result=new ArrayList<>();
        Arrays.sort(nums);
        for(int i=0;i<nums.length;i++){
            //第一个大于0，后面都大于零，加起来不可能等于0
            if(nums[i]>0){
                return result; 
            }
            //当相邻两个数一样的时候，跳过去重，且是跟前一个元素相比，所以要去掉第一个元素
             if (i > 0 && nums[i] == nums[i - 1]) {  // 去重a
                continue;
            }
            left=i+1;
            right=nums.length-1;
            while(left<right){
            if(nums[right]+nums[left]+nums[i]>0){
                right--;

            }
            else if(nums[right]+nums[left]+nums[i]<0){
                left++;
            }else{
            List<Integer>list=new ArrayList<>();
            /*list.add(nums[i]);
            list.add(nums[left]);
            list.add(nums[right]);
            result.add(list);*/
            result.add(Arrays.asList(nums[i], nums[left], nums[right]));
            while(left<right&&nums[right]==nums[right-1])right--;
            while(left<right&&nums[left]==nums[left+1])left++;
            left++;
            right--;
                }
               
            }
            
        }
         return result;

    }
}

第18题. 四数之和

视频链接：难在去重和剪枝！| LeetCode：18. 四数之和_哔哩哔哩_bilibili

题意：给定一个包含 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] ]

思路

比上题多了一个for循环。

代码

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
         for (int i = 0; i < nums.length; i++) {
		
            // nums[i] > target 直接返回, 剪枝操作，注意nums[i]要大于0，负数越加越小
            if (nums[i] > 0 && nums[i] > target) {
                return result;
            }
		
            if (i > 0 && nums[i - 1] == nums[i]) {    // 对nums[i]去重
                continue;
            }
            
            for (int j = i + 1; j < nums.length; j++) {

                if (j > i + 1 && nums[j - 1] == nums[j]) {  // 对nums[j]去重
                    continue;
                }

                int left = j + 1;
                int right = nums.length - 1;
                while (right > left) {
		    // nums[k] + nums[i] + nums[left] + nums[right] > target int会溢出
                    long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum > target) {
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        result.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                        //去重
                        while (right > left && nums[right] == nums[right - 1]) right--;
                        while (right > left && nums[left] == nums[left + 1]) left++;

                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
    }
    }

太绕了，不熟练