【算法-哈希表】

Ted0067

已于 2023-08-16 11:08:15 修改

阅读量39

点赞数

文章标签：算法散列表数据结构

于 2023-08-14 19:03:39 首次发布

本文链接：https://blog.csdn.net/Ted0067/article/details/132281741

版权

哈希表基础

在key值连续确定且有限可数的情况下, 可以使用数组作为简单hash表
在HashMap的实现中, 先使用hash对存入的对象计算取值, 再对得出的hash取余(%数组长度), 以此为key存在数组中, 取值时,再计算hash取余即可.

但, 当hash内的数据足够多时, hash取余的结果会有相等的情况, 此时称之为hash碰撞, 发生hash碰撞时, 会在数组的槽位上使用一个链表去存储hash取余一致的对象, 在取值时挨个遍历取等, 在链表长度到了一定长度时, 链表会优化为红黑树.
拉链法

练习

242.有效的字母异位词

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

注意：`若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。`

即:

示例 1:

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

示例 2:

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

思路1:

两个单词内字母出现的次数相同, 只是次序不同而已. 则可将两个字符串分别排序, 遍历判断两个排序列表的值是否完全相等.

代码实现:

public boolean isAnagram_sort(String s, String t) {
    if (s.length() != t.length()) {
        return false;
    }
    char[] cs = s.toCharArray();
    Arrays.sort(cs);
    char[] ct = t.toCharArray();
    Arrays.sort(ct);
    for (int i = 0; i < cs.length; i++) {
        if (cs[i] != ct[i]) {
            return false;
        }
    }
    return true;
}

思路2:

使用hash表, 先遍历字符串1, 以字符为key, 出现次数为value值, 存入hash表中, 字符每出现1次则value+1. 再遍历字符串2, 字符每出现1次则value-1. 最终检查hash表, 若所有value都为0, 则两个字符串互为字母异位词.

注: `当key值确定有限(数值较小), 且可以使用用数字, 则可使用数组作为hash表, 其下标作为key, 对应的值作为value`

代码实现:

public boolean isAnagram(String s, String t) 
    // 若长度不同则必定不是
    if (s.length() != t.length()) {
        return false;
    }
    // 以数组作为hash表使用, 字符的ASCII作为key
    int[] arr = new int[26];
    // 遍历字符串1 每出现一个字符串 对应值+1
    for (char c : s.toCharArray()) {
        arr[c - 'a']++;
    }
    // 遍历字符串2 每出现一个字符串 对应值-1
    for (char c : t.toCharArray()) {
        arr[c - 'a']--;
    }
    // 检查是否结果全为0
    for (int i : arr) {
        if (i != 0) {
            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] 也是可通过的

思路:

如题: 出结果中的每个元素一定是唯一的, 则可以使用set对结果集去重.
可以通过遍历, 使用set记录下第一个数组的所有数据, 再遍历第二个数组时, 判断该元素是否存在于第一个数组, 若存在, 则使用第二个Set将这些元素收集起来.
也可以直接遍历第二个数组, 判断当前元素是否存在于数组1, 若存在, 则使用Set将这些元素收集起来.
最终都将Set转换为数组返回.

代码实现:

public int[] intersection(int[] nums1, int[] nums2
    Set<Integer> res = new HashSet<>();
    for (int i : nums2) {
        if (contains(nums1, i)) {
            res.add(i);
        }
    }
    int[] arr = new int[res.size()];
    int i = 0;
    for (Integer integer : res) {
        arr[i++] = integer;
    }
    return arr;
}
private boolean contains(int[] arr, int a) {
    for (int i : arr) {
        if (a == i) {
            return true;
        }
    }
    return false;
}

第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

思路:

如题, 结果可能 无限循环, 则使用HashSet将结果集记录下了, 若出现重复的结果集, 则说明该数不为快乐数.

代码实现:

public boolean isHappy(int n) {
   Set<Integer> record = new HashSet<>();
   while (n != 1 && !record.contains(n)) {
       record.add(n);
       n = getNext(n);
   }
   return n == 1;
}
private int getNext(int n) {
   int sum = 0;
   while (n > 0) {
       int i = n % 10;
       sum += i * i;
       n = n / 10;
   }
   return sum;
}

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]

思路1: 暴力解法

遍历两个数值, 穷举每一种情况.

代码实现:

/**
* 暴力法
*/
public int[] twoSum_force(int[] nums, int target) {
  for (int i = 0; i < nums.length; i++) {
      for (int j = 1; j < nums.length; j++) {
          if (i != j && nums[i] + nums[j] == target) {
              return new int[]{i, j};
          }
      }
  }
  return null;
}

思路2:

使用HashMap记录下每一个遍历过的值, 以该值为key, 下标为value, 在遍历下一个值时, 将target减去当前值, 获取的结果作为key到HashMap中获取, 若存在, 则说明数组中存在两个数相加为target, 反之, 则继续遍历, 重复之前的操作.

代码实现:

public int[] twoSum(int[] nums, int target) {
   int[] res = new int[2];
   if(nums == null || nums.length == 0){
       return res;
   }
   Map<Integer, Integer> map = new HashMap<>();
   for (int i = 0; i < nums.length; i++) {
       int temp = target - nums[i];
       if (map.containsKey(temp)) {
           res[0] = i;
           res[1] = map.get(temp);
           return res;
       }
       map.put(nums[i], i);
   }
   return res;
}

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
3.

示例 2：

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

代码实现:

public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
   int count = 0;
   // 记录出现的次数 
   Map<Integer, Integer> map = new HashMap<>();
   // 两两分组 使用map记录前两组sum出现的次数
   for (int i : nums1) {
       for (int j : nums2) {
           int sum = i + j;
           map.put(sum, map.getOrDefault(sum, 0) + 1);
       }
   }
   // 遍历后两组 通过 -sum 在map中反取 累加
   for (int k : nums3) {
       for (int l : nums4) {
           count += map.getOrDefault(-k - l, 0);
       }
   }
   return count;
}

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

思路:

和有效的字母异位词思路类似, 使用数组作为hash表, 先记录下杂志上所有字母的数量信息, 再依次减去信件内的字母信息, 若将杂志的字母用完, 则直接返回fasle.

代码实现:

public boolean canConstruct(String ransomNote, String magazine) {
   int[] arr = new int[26];
   char[] magazineArray = magazine.toCharArray();
   for (char c : magazineArray) {
       arr[c - 'a']++;
   }
   char[] ransomNoteArray = ransomNote.toCharArray();
   for (char c : ransomNoteArray) {
       arr[c - 'a']--;
       if (arr[c - 'a'] < 0) {
           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 。

思路: 双指针法

先将数组排序 [-1, 0, 1, 2, -1, -4] => [-4, -1, -1, 0, 1, 2]
遍历数组获取下标 i 对应的值 i+1(左指针) 对应的值, n - 1(右指针) 对应的值
三数之和, 若 >0 则右指针左移, <0 则左指针右移动
在遍历时, 对i去重, 若 i>0 (非数组第一个), 则比较数组前一个值和当前值, 若相等, 则该值已得出结果, 跳过即可. 去重其他值同理

代码实现:

/**
* 三数之和
* @param nums = [-1, 0, 1, 2, -1, -4]，
*/
public List<List<Integer>> threeSum(int[] nums) {
   List<List<Integer>> res = new ArrayList<>();
   // 排序 [-4, -1, -1, 0, 1, 2]
   Arrays.sort(nums);
   int n = nums.length;
   for (int i = 0; i < nums.length - 2; i++) {
       // 去重i 若后一位的i 与已经遍历过的的i数值一致, 则跳过 如 -1, -1
       if (i > 0 && nums[i] == nums[i - 1]) {
           continue;
       }
       int j = i + 1;
       int k = n - 1;
       while (j < k) {
           // 去重j 若后一位的j 与已经遍历过的的j数值一致, 则j右移一位 如 -1, -1
           while (j > i + 1 && j < n && nums[j] == nums[j - 1]) {
               j++;
           }
           // 若j右移到头则跳出循环
           if (j >= k) {
               break;
           }
           // 获取三数之和
           int sum = nums[i] + nums[j] + nums[k];
           if (sum == 0) {
               // 相等则记录结果
               res.add(Arrays.asList(i, j, k));
               // j右移 继续遍历
               j++;
           } else if (sum > 0) {
               // 值大于0 则说明右数太大 左移一位
               k--;
           } else {
               // 值小于0 则说明左数太大 右移一位
               j++;
           }
       }
   }
   return res;
}

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]]

思路: 双指针法

与三数之和类似, 只不过多套了一层, 可以多加一些减枝的手法, 列如判断最小的数若都已大于target则直接跳, 若当前值与最大的3个值仍然小于target, 也跳过.

代码实现:

public List<List<Integer>> fourSum(int[] nums, int target) {
   List<List<Integer>> quadruplets = new ArrayList<>();
   if (nums == null || nums.length < 4) {
       return quadruplets;
   }
   // 排序
   Arrays.sort(nums);
   int length = nums.length;
   for (int i = 0; i < length; i++) {
       // 去重i
       if (i > 0 && nums[i] == nums[i - 1]) {
           continue;
       }
       for (int j = i + 1; j < length; j++) {
           // 去重j
           if (j > i + 1 && nums[j] == nums[j - 1]) {
               continue;
           }
           int left = j + 1;
           int right = 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 {
                   quadruplets.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 quadruplets;
}