代码随想录——JAVA算法题——哈希表

最新推荐文章于 2024-11-12 21:14:07 发布
最新推荐文章于 2024-11-12 21:14:07 发布
阅读量1k 收藏 17
点赞数 11
文章标签： java 算法 散列表 数据结构 哈希
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55902321/article/details/141959233
版权

JAVA算法题——哈希表

有效的字母异位词

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

示例 1:

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

示例2：

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

提示：

1 <= s.length, t.length <= 5 * 10^4
s 和 t 仅包含小写字母

JAVA代码：

public class Main {
    public static void main(String[] args) {
        String s = "rat";
        String t = "car";
        System.out.println(isAnagram(s,t));

    }
    public static boolean isAnagram(String s, String t) {
        int[] arr1 = new int[26];
        int[] arr2 = new int[26];
        for (int i = 0; i < s.length(); i++) {
            arr1[s.charAt(i)-'a']++;
        }
        for (int i = 0; i < t.length(); i++) {
            arr2[t.charAt(i)-'a']++;
        }
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }
        return true;
    }
}

两个数组的交集

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

示例 1:

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的

提示：

1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000

JAVA代码：

public class  Main {
    public static void main(String[] args) {
        int[] nums1 = {4,9,5};
        int[] nums2 = {9,4,9,8,4};
        int[] res = intersection(nums1,nums2);
        for (int i = 0; i < res.length; i++) {
            System.out.printf("%d\t",res[i]);
        }
    }
    public static int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> set2 = new HashSet<>();
        for (int i = 0; i < nums1.length; i++) {
            set1.add(nums1[i]);
        }
        for (int i = 0; i < nums2.length; i++) {
            if (set1.contains(nums2[i])) {
                set2.add(nums2[i]);
            }
        }
        int[] res = new int[set2.size()];
        int i = 0;
        for (int number : set2) {
            res[i] = number;
            i++;
        }
        return res;
    }
}

快乐数

力扣题目349链接
编写一个算法来判断一个数 n 是不是快乐数。
【快乐数】 定义为：
对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

示例 1:

输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

示例2：

输入：n = 2
输出：false

提示：

1 <= n <= 2^31 - 1

JAVA代码：

public class Main {
    public static void main(String[] args) {
        int n = 1000;
        boolean res = isHappy(n);
        System.out.println(res);
    }
    public static boolean isHappy(int n) {
        HashSet<Integer> set = new HashSet<>();
        int temp = 0;
        while (n != 1) {
            if (set.contains(n)) {
                return false;
            }
            set.add(n);
            temp = 0;
            while (n != 0) {
                temp += (n % 10) * (n % 10);
                n = n / 10;
            }
            n = temp;
        }
        return true;
    }
}

两数之和

力扣题目1链接
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。
你可以按任意顺序返回答案。

示例 1:

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

2 <= nums.length <= 10^4
-10^9 <= nums[i] <= 10^9
-10^9 <= target <= 10^9
只会存在一个有效答案

JAVA代码：

public class Main {
    public static void main(String[] args) {
        int[] nums = {3,3};
        int target = 6;
        int[] res = twoSum(nums, target);
        for (int i = 0; i < res.length; i++) {
            System.out.println(res[i]);
        }
    }
    public static int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> map = new HashMap<>();
        int[] res = new int[2];
        for (int i = 0; i < nums.length; i++) {

            if (map.containsKey(target - nums[i])) {
                res[0] = map.get(target - nums[i]);
                res[1] = i;
            }
            map.put(nums[i],i);

        }
        return res;
    }
}

四数相加 2

力扣题目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

示例 1:

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

示例2：

输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出：1

提示：

n == nums1.length
n == nums2.length
n == nums3.length
n == nums4.length
1 <= n <= 200
-2^28 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 2^28

JAVA代码：

public class Main {
    public static void main(String[] args) {
        int[] nums1 = {1,2};
        int[] nums2 = {-2,-1};
        int[] nums3 = {-1,2};
        int[] nums4 = {0,2};
        System.out.println(fourSumCount(nums1, nums2, nums3, nums4));
    }
    public static int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer,Integer> map = new HashMap<>();
        int res = 0;
        for (int i : nums1) {
            for (int j : nums2) {
                int sum = i + j;
                map.put(sum,map.getOrDefault(sum, 0)+1);
            }
        }
        for (int i : nums3) {
            for (int j : nums4) {
                res += map.getOrDefault(-i-j,0);
            }
        }
        return res;
    }
}

赎金信

力扣题目383链接
给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。

示例 1:

输入：ransomNote = "a", magazine = "b"
输出：false

示例2：

输入：ransomNote = "aa", magazine = "ab"
输出：false

示例3：

输入：ransomNote = "aa", magazine = "aab"
输出：true

提示：

1 <= ransomNote.length, magazine.length <= 10^5
ransomNote 和 magazine 由小写英文字母组成

JAVA代码：

public class Main {
    public static void main(String[] args) {
        String ransomNote = "aa";
        String magazine = "aab";
        System.out.println(canConstruct(ransomNote, magazine));

    }
    public static boolean canConstruct(String ransomNote, String magazine) {
        int[] num1 = new int[26];
        int[] num2 = new int[26];
        for (int i = 0; i < ransomNote.length(); i++) {
            num1[ransomNote.charAt(i)-'a']++;
        }
        for (int i = 0; i < magazine.length(); i++) {
            num2[magazine.charAt(i)-'a']++;
        }
        for (int i = 0; i < num1.length; i++) {
            if (num1[i] > num2[i]) {
                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 且不重复的三元组。
注意：答案中不可以包含重复的三元组。

示例 1:

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

提示：

3 <= nums.length <= 3000
-10^5 <= nums[i] <= 10^5

JAVA代码：

public class Main {
    public static void main(String[] args) {
        int[] nums = {-1,0,1,2,-1,-4};
        System.out.println(threeSum(nums));
    }
    public static List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i <= nums.length-3; i++) {
            if (i != 0 && nums[i] == nums[i-1]) {
                continue;
            }
            int left = i + 1;
            int right = nums.length - 1;
            while (right > left) {
                List<Integer> list = new ArrayList<>();
                int sum = nums[i] + nums[left] + nums[right];
                if (sum < 0) {
                    left++;
                } else if (sum > 0) {
                    right--;
                } else {
                    list.add(nums[i]);
                    list.add(nums[left]);
                    list.add(nums[right]);
                    result.add(list);
                    while (right > left && nums[right] == nums[right-1]) right--;
                    while (right > left && nums[left] == nums[left+1]) left++;
                    left++;
                    right--;
                }
            }
        }
        return result;
    }
}

四数之和

力扣题目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
你可以按 任意顺序 返回答案 。

示例 1:

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

提示：

1 <= nums.length <= 200
-10^9 <= nums[i] <= 10^9
-10^9 <= target <= 10^9

JAVA代码：

public class Main {
    public static void main(String[] args) {
        int[] nums = {1000000000,1000000000,1000000000,1000000000};
        int target = -294967296;
        System.out.println(fourSum(nums, target));
    }
    public static List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i <= nums.length-4; i++) {
            if (i != 0 && nums[i] == nums[i-1]) {
                continue;
            }
            for (int j = i + 1; j <= nums.length-3; j++) {
                if (j != i + 1 && nums[j] == nums[j-1]) {
                    continue;
                }
                int left = j + 1;
                int right = nums.length - 1;
                while (left < right) {
                    long sum = (long)nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum > target) {
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        List<Integer> list = new ArrayList<>();
                        list.add(nums[i]);
                        list.add(nums[j]);
                        list.add(nums[left]);
                        list.add(nums[right]);
                        result.add(list);
                        while (right > left && nums[right] == nums[right-1]) right--;
                        while (right > left && nums[left] == nums[left+1]) left++;
                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
    }
}
@H³M
关注
洛谷P5546公共串的SAM解法代码（含二分哈希）
qq_73633818的博客
08-31 650
我看网上大部分都是二分哈希的做法但却没有后缀自动机SAM的解法代码，因此提供两个SAM的解法，两个解法我都不详细介绍，会提供原文章地址和我个人的代码。个人认为第二种解法在时间和空间复杂度上都更优，也更好理解（前提你熟悉两个字符串情况下的SAM解法）。
代码随想录——Java刷题记录
Kixuan214的博客
11-06 273
代码随想录Java刷题记录（更新中）
代码随想录——哈希表
做一个善良的人，做好自己的事，如果愿意，再发一份光。
07-09 321
🔥本篇概览：数据结构与算法 || 详细讲解了哈希表的篇章。🌈⭕🔥
代码随想录——哈希表学习记录
jackelove1的博客
10-13 320
哈希表学习记录
代码随想录——回溯算法
m0_65859678的博客
08-29 762
组合和排列的区别：组合不强调元素的顺序，而排列强调元素顺序回溯法解决的问题都可以抽象为树形结构，。回溯法模板：回溯函数模板返回值及参数回溯函数终止条件回溯搜索的遍历过程for循环就是遍历集合区间，可以理解一个节点有多少个孩子，这个for循环就执行多少次。，这样就把这棵树全遍历完了，一般来说，搜索叶子节点就是找的其中一个结果了。
代码随想录——哈希表（Java）
weixin_52150845的博客
03-28 384
整理代码随想录哈希法部分
代码随想录刷题3——哈希表
m0_46254725的博客
03-26 734
在242.有效的字母异位词 (opens new window)中，我们提到了数组就是简单的哈希表，但是数组的大小是受限的！这道题目包含小写字母，那么使用数组来做哈希最合适不过。在383.赎金信 (opens new window)中同样要求只有小写字母，那么就给我们浓浓的暗示，用数组！
代码随想录——链表
做一个善良的人，做好自己的事，如果愿意，再发一份光。
07-09 406
🔥本篇概览：数据结构与算法 || 详细讲解了链表篇章。🌈⭕🔥
代码随想录24——哈希表1——初识基础
做一个善良的人，做好自己的事，如果愿意，再发一份光。
06-17 1108
🔥本篇概览：数据结构与算法||详细讲解了哈希表的基本实现、哈希函数、存在的问题、基本解决方法等等。🌈⭕🔥
代码随想录-力扣刷题-总结笔记01
upward
02-27 1196
代码随想录-力扣刷题-总结笔记01
day02 | 代码随想录 训练营
qq_41682022的博客
12-07 837
二分
算法分析之链表问题
小朱小朱绝不认输的博客
12-01 1657
文章目录一、链表理论基础1. 链表的介绍2. 链表的类型1）单链表2）双链表3）循环链表3. 链表的存储方式4. 链表的定义5. 链表的操作1）删除节点2）添加节点6. 头指针和头节点二、leetcode例题讲解数组问题203. 移除链表元素707. 设计链表206. 反转链表24. 两两交换链表中的节点19. 删除链表的倒数第 N 个结点面试题 02.07. 链表相交142. 环形链表 II 链表是除数组外，另一个常用的数据结构，算法中经常会对链表进行处理，主要是指针的用法。 一、链表理论基础 1. 链表
算法分析之数组问题
小朱小朱绝不认输的博客
11-30 2611
文章目录一、数组理论基础二、leetcode例题讲解数组问题 一、数组理论基础 数组是非常基础的数据结构。 首先要知道数组在内存中的存储方式：数组是存放在连续内存空间上的相同类型数据的集合。 数组可以方便的通过下标索引的方式获取到下标下对应的数据。 需要两点注意的是： 数组下标都是从0开始的。 数组内存空间的地址是连续的。 正是因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。 数组的元素是不能删的，只能覆盖。 二维数组在内存的空间地址是连续的么？在Jav
算法分析之二叉树
小朱小朱绝不认输的博客
12-13 1973
文章目录一、二叉树的定义二、二叉树的种类1. 满二叉树2. 完全二叉树3. 二叉搜索树4. 平衡二叉搜索树三、二叉树的存储方式四、二叉树的遍历方式 一、二叉树的定义 二叉树在算法中是比较常用的数据结构，根据二叉树的遍历算法，在算法题中遇到二叉树经常优先考虑递归算法。同时二叉树中的二叉搜索树也是常用的，主要结合中序遍历有序的特性。 二叉树结构： public class TreeNode { int val; TreeNode left; TreeNode right; Tre
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 205
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
1112--接口
最新发布
kequanrrr的博客
11-12 221
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
SpringBoot 实现图片加水印
心猿意码
11-11 332
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
JAVA-01-变量
LJH_laura_li的博客
11-08 482
在方法、构造函数或块内部定义的变量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值