😀如果对你有帮助的话😊
🌺为博主点个赞吧 👍
👍点赞是对博主最大的鼓励😋
💓爱心发射~💓
目录
基础知识
-
哈希表是根据关键码的值而直接进行访问的数据结构。
-
一般哈希表都是用来快速判断一个元素是否出现集合里。
哈希函数
总结
总结一下,当我们遇到了要快速判断一个元素是否出现集合里的时候,就要考虑哈希法。但是哈希法也是牺牲了空间换取了时间,因为我们要使用额外的数组,set或者是map来存放数据,才能实现快速的查找。
242. 有效的字母异位词——简单
给定两个字符串 s
和 t
,编写一个函数来判断 t
是否是 s
的字母异位词。
注意:若 s
和 t
中每个字符出现的次数都相同,则称 s
和 t
互为字母异位词。
示例 1:
输入: s = "anagram", t = "nagaram"
输出: true
示例 2:
输入: s = "rat", t = "car"
输出: false
代码
class Solution {
public boolean isAnagram(String s, String t) {
//判断是否相等
if(s.length() != t.length()) return false;
//存入 减去
int[] a = new int[26];
for(int i=0; i<s.length(); ++i){
a[s.charAt(i)-'a']++;
a[t.charAt(i)-'a']--;
}
// 判断结果是否为0
for(int i=0; i<26; ++i){
if(a[i] != 0) return false;
}
return true;
}
}
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
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
if(ransomNote.length() > magazine.length()) return false;
int[] a = new int[26];
for(char i : magazine.toCharArray()){
a[i -'a']++;
}
for(char i : ransomNote.toCharArray()){
a[i-'a']--;
if(a[i-'a'] < 0){
return false;
}
}
return true;
}
}
49. 字母异位词分组——中等
给你一个字符串数组,请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。
字母异位词 是由重新排列源单词的字母得到的一个新单词,所有源单词中的字母通常恰好只用一次。
示例 1:
输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
示例 2:
输入: strs = [""]
输出: [[""]]
示例 3:
输入: strs = ["a"]
输出: [["a"]]
1、排序
class Solution {
public List<List<String>> groupAnagrams(String[] strs) {
// 存放字符串
Map<String, List<String>> map = new HashMap<String, List<String>>();
for(String str : strs){
// 将字符串换为数组
char[] array = str.toCharArray();
// 数组排序
Arrays.sort(array);
// 返回字符串
String key = new String(array);
// 判断数组里有字符串吗
List<String> list = map.getOrDefault(key, new ArrayList<String>());
list.add(str);
map.put(key, list);
}
return new ArrayList<List<String>>(map.values());
}
}
2、stream 的 grouping
class Solution {
public List<List<String>> groupAnagrams(String[] strs) {
// // stream 的 groupingBy
// // groupingBy 算子计算完以后,返回的是一个 Map<String, List<String>>
// // Collector是专门用来作为Stream的collect方法的参数的。
// // collect 可以收集流中的数据到【集合】或者数组中去
// // groupingBy 根据字符串进行分组
return new ArrayList<>(Arrays.stream(strs)
.collect(Collectors.groupingBy(
str->{
//将str转换为数组
char[] array = str.toCharArray();
//排序
Arrays.sort(array);
//返回排序后的数组
return new String(array);
}
)).values()
);
}
}
438. 找到字符串中所有字母异位词——中等
给定两个字符串 s
和 p
,找到 s
中所有 p
的 异位词 的子串,返回这些子串的起始索引。不考虑答案输出的顺序。
异位词 指由相同字母重排列形成的字符串(包括相同的字符串)。
示例 1:
输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。
示例 2:
输入: s = "abab", p = "ab"
输出: [0,1,2]
解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。
方法一:滑动窗口
class Solution {
//方法一:滑动窗口
public List<Integer> findAnagrams(String s, String p) {
// 字符串长
int slen = s.length();
int plen = p.length();
// s<p 直接返回
if(slen < plen ){
return new ArrayList<Integer>();
}
// 定义数组存索引
List<Integer> num = new ArrayList<Integer>();
// 定义两个数组存字符串
int[] sCount = new int[26];
int[] pCount = new int[26];
// 先判断开始是否与p相同,返回0
for(int i=0; i<plen; ++i){
++sCount[s.charAt(i)-'a'];
++pCount[p.charAt(i)-'a'];
}
if(Arrays.equals(sCount,pCount)){
num.add(0);
}
// 继续判断下一位
for(int i=0; i<slen-plen; ++i){
--sCount[s.charAt(i)-'a'];
++sCount[s.charAt(i+plen)-'a'];
if(Arrays.equals(sCount,pCount)){
num.add(i+1);
}
}
return num;
}
}
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] 也是可通过的
方法一:两个集合
class Solution {
public int[] intersection(int[] nums1, int[] nums2) {
if(nums1==null || nums1.length==0 ||nums2==null || nums2.length==0){
return new int[0];
}
Set<Integer> set1 = new HashSet<>();
Set<Integer> resSet = new HashSet<>();
//遍历数组1
for(int i : nums1){
set1.add(i);
}
//遍历数组2 判断哈希表中是否存在该元素
for(int i :nums2){
if(set1.contains(i)){
resSet.add(i);
}
}
//将字符串转换成数组
int[] result = new int[resSet.size()];
int index = 0;
for(int i : resSet){
result[index++] = i;
}
return result;
}
}
350. 两个数组的交集 II——简单
力扣
给你两个整数数组 nums1
和 nums2
,请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数,应与元素在两个数组中都出现的次数一致(如果出现次数不一致,则考虑取较小值)。可以不考虑输出结果的顺序。
示例 1:
输入:nums1 = [1,2,2,1], nums2 = [2,2]
输出:[2,2]
示例 2:
输入:nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出:[4,9]
方法一:哈希表
class Solution {
public int[] intersect(int[] nums1, int[] nums2) {
// 先循环 短的数组 将短数组存起来
if(nums1.length > nums2.length){
return intersect(nums2,nums1); // 交换位置
}
//创建 HashMap
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
// 将前一个数组存进去
// map.getOrDefault() 方法获取指定 key 对应对 value,如果找不到 key ,则返回设置的默认值
for(int i : nums1) {
int count = map.getOrDefault(i, 0) + 1;
map.put(i, count);
}
// 循环第二个数组 有相同的数,count值减1
// 再判断count的值是否为0,不为0,存入新的(key, value),为0, 移除数
int index = 0;
int[] result = new int[nums1.length];
for(int i:nums2){
int count = map.getOrDefault(i, 0);
if(count>0){
result[index++] = i;
count--;
if(count>0){
map.put(i, count);
}else{
map.remove(i);
}
}
}
// 对一个已有的数组进行截取复制,copyOfRange(原数组,开始下标,结束下标)
return Arrays.copyOfRange(result, 0, index);
}
}
202. 快乐数——简单
编写一个算法来判断一个数 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 <= 231 - 1
方法一:用哈希集合检测循环
class Solution {
public boolean isHappy(int n) {
Set<Integer> seen = new HashSet<>();
while(n != 0 && !seen.contains(n)){
seen.add(n);
n = getNext(n);
}
return n==1;
}
private int getNext(int n){
int next = 0;
while(n>0){
int a = n % 10;
n = n / 10;
next += a * a;
}
return next;
}
}
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]
方法二:哈希表
class Solution {
public int[] twoSum(int[] nums, int target) {
// 创建一个哈希表
// key——数 value——下标
Map<Integer, Integer> table = new HashMap<Integer,Integer>();
// 循环数组 1、从哈希表中看是否有数据与本数相加为target,存在直接返回数组(哈希表中数的value,与此数的坐标)
// 2、将数存到 哈希表中
for(int i = 0; i< nums.length; ++i){
if(table.containsKey(target - nums[i])){
return new int[]{table.get(target-nums[i]), i};
}
table.put(nums[i], i);
}
// 如果数组中不存在满足条件的数,就返回0
return new int[0];
}
}
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
示例 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
HashMap
class Solution {
public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
// 判断四个数组相加为0,将数组分成两组
// 第一组的两数之和,判断是否有这个值,先存入哈希表中 key为两数之和 value为 有这个值的次数
// 第二组:判断这两个数和的相反数 是否在哈希表中,有result加1,
Map<Integer,Integer> table = new HashMap<Integer,Integer>();
int result = 0;
//第一组
for(int i=0; i<A.length; ++i){
for(int j=0; j<B.length; ++j){
int sumab = A[i]+B[j];
if(table.containsKey(sumab)){
table.put(sumab,table.get(sumab)+1);
}else{
table.put(sumab, 1);
}
}
}
//第二组
for(int i=0; i<C.length; ++i){
for(int j=0; j<D.length; ++j){
int sumcd = -C[i] - D[j];
if(table.containsKey(sumcd)){
result += table.get(sumcd);
}
}
}
return result;
}
}
15. 三数之和——中等
给你一个包含 n
个整数的数组 nums
,判断 nums
中是否存在三个元素 a,b,c ,使得 a + b + c = 0 ?请你找出所有和为 0
且不重复的三元组。
注意:答案中不可以包含重复的三元组。
示例 1:
输入:nums = [-1,0,1,2,-1,-4]
输出:[[-1,-1,2],[-1,0,1]]
示例 2:
输入:nums = []
输出:[]
示例 3:
输入:nums = [0]
输出:[]
排序 + 双指针
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> lists = new ArrayList<>();
int len = nums.length;
// 特殊情况的数组
if(len<3 || nums == null) return lists;
// 数组排序
Arrays.sort(nums);
// 双指针循环
// 1、nums[i]>0 直接return,因为后边不可能等于0
// 2、重复元素跳过
// 3、当 l < r,进循环,result==0,存数据,result<0,l右移。result>0,r左移
for(int i=0; i<len; ++i){
if(nums[i]>0) return lists;
if(i>0 && nums[i] == nums[i-1]) continue;
int l=i+1, r=len-1;
while(l<r){
int result = nums[i] + nums[l] + nums[r];
if(result==0){
List<Integer> bb = new ArrayList<>();
bb.add(nums[i]);
bb.add(nums[l]);
bb.add(nums[r]);
lists.add(bb);
while(l<r && nums[l+1] == nums[l]) ++l;
while(l<r && nums[r-1] == nums[r]) --r;
++l;
--r;
}else if(result<0){
++l;
}else{
--r;
}
}
}
return lists;
}
}
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]]
排序+双指针
class Solution {
public List<List<Integer>> fourSum(int[] nums, int target) {
// 根据三数之和 ——两层for循环
// 第一个for循环第一个数,第二个for循环第二个数
// 双指针 l-第三个数,r-第四个数
List<List<Integer>> lists = new ArrayList<>();
int len = nums.length;
Arrays.sort(nums);
for(int i=0; i<len; ++i){
// 与上一个数相同,跳过
if(i>0 && nums[i-1] == nums[i]){
continue;
}
for(int j=i+1; j<len; ++j){
// 去重
if(j>i+1 && nums[j-1] == nums[j]){
continue;
}
int l = j+1, r = len-1;
while(l < r){
int result = nums[i] + nums[j] + nums[l] + nums[r];
if(result == target){
List<Integer> b = new ArrayList<>();
b.add(nums[i]);
b.add(nums[j]);
b.add(nums[l]);
b.add(nums[r]);
lists.add(b);
while(l<r && nums[r-1] == nums[r]) --r;
while(l<r && nums[l+1] == nums[l]) ++l;
--r;
++l;
}else if(result < target){
++l;
}else{
--r;
}
}
}
}
return lists;
}
}