• 【数据结构】哈希表

    目录

    1.概念

    2.哈希冲突 

    3.常见哈希函数

    3.1直接定制法

    3.2除留余数法

    4.负载因子调节

    4.1冲突解决-闭散列

    1.线性探测

    2.二次探测 

    4.2冲突解决-开散列

    5.实现哈希表

    5.1Integer类型

    5.2引用类型

    6.哈希表oj题 

    1）只出现一次的数字

    2）复制带随机指针的链表

    3）石与石头

    4）坏键盘打字

    5）前k个高频单词

    1.概念

    理想的搜索方法：不经过任何比较，一次直接从表中得到要搜索的元素。

    哈希表就可以实现这种功能：构造一种存储结构，通过某种函数使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

    该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(HashTable)(或者称散列表)。

    例如：数据集合{1，7，6，4，5，9}；
    哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。

    这样一一映射的关系就使搜索的速度非常快了。

    但是——在上述集合基础上插入数据14，会出现什么问题？

    2.哈希冲突 

    由上易知：14和4所放入的位置冲突了。

    不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。

    注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突.

    3.常见哈希函数

    3.1直接定制法

    取关键字的某个线性函数为散列地址：Hash(key) = A*key + B

    优点：简单、均匀；缺点：需要事先知道关键字的分布情况.

    适用场景：适合查找比较小且连续的情况.

    面试题：字符串中第一个只出现一次的字符

    3.2除留余数法

    设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key % p (p<=m)，将关键码转换成哈希地址.

    还有一些只需要了解的方法：

    平方取中法：假设关键字为1234，平方后为1522756，抽取中间的3位227作为哈希地址； 再比如关键字为4321，平方后为18671041，抽取中间的3位671(或710)作为哈希地址.

    适用场景：不知道关键字的分布，且位数不是很大的情况.

    折叠法：将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址.

    适用场景：事先不需要知道关键字的分布，适合关键字位数比较多的情况.

    随机数法：选择一个随机函数，取关键字的随机函数值为它的哈希地址，即Hash(key) = random(key),其中random为随机数函数.

    适用场景：关键字长度不等的情况.

    数字分析法：根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址.

    适用场景：关键字位数比较大，事先知道关键字的分布且关键字的若干位分布较均匀的情况.

    4.负载因子调节

    散列表的载荷因子定义：α = 填入表中的元素个数 / 散列表的长度

    α 越大，说明填入表中的元素越多，产生冲突的可能性就越大，已知哈希表中已有的关键字个数是不可变的，所以我们只能调整哈希表中的数组的大小。

    解决哈希冲突的常见方法：闭散列和开散列：

    4.1冲突解决-闭散列

    闭散列，又叫开放定址法。当发生哈希冲突时，如果哈希表未被填满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个”空位置中去。

    问题是：如何寻找下一个空位置呢？

    1.线性探测

    从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

    注意：采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。

    2.二次探测 

    只是单纯挨个向后探测，数据量大的情况下还是会有很大概率出现哈希冲突，二次探测为了避免该问题，更换了寻找下一个空位的方法：Hi = (Ho+i^2)%m，或Hi = (Ho-i^2)%m。其中 i=1,2,……，Ho是通过散列函数Hash(x)对元素关键码key进行计算得到的位置，m是表的大小。

    研究表明：当表的长度为质数且表的负载因子α不超过0.5时，新的表项一定能够插入，且任何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子α不超过0.5，如果超出必须考虑扩容。

    ——因此，闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

    4.2冲突解决-开散列

    开散列，又叫链地址法(开链法)。首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头点存储在哈希表中。

     

    这就是将大集合的搜索问题转化为小集合的搜索问题，但如果冲突严重，就意味着小集合的搜索性能其实也是不佳的，这个时候我们就可以将这个所谓的小集合搜索问题继续进行转化，例如：每个桶的背后是另一个哈希表或每个桶的背后是一棵搜索树。

    5.实现哈希表

    5.1Integer类型

    1. public class HashBuck {
    2.     static class Node { //静态内部类
    3.         private int key;
    4.         private int value;
    5.         private Node next;
    6.         public Node(int key, int value) {
    7.             this.key = key;
    8.             this.value = value;
    9.         }
    10.     }
    11.     public Node[] array;
    12.     public int usedSize;
    13.     private static final float DEFAULT_LOAD_FACTOR = 0.75f; //负载因子默认为0.75
    14.     public HashBucket() {
    15.         this.array = new Node[10]; //初始大小为10
    16.     }
    17.     //计算负载因子
    18.     private float loadFactor() {
    19.         return usedSize*1.0f/array.length;
    20.     }
    21.     // 插入
    22.     public void put(int key,int val) {
    23.         Node node = new Node(key,val);
    24.         int index = key % array.length;//找到元素对应的位置
    25.         Node cur = array[index];
    26.         while (cur != null) { //遍历index位置下方的链表
    27.             if(cur.key == key) { //插入的元素已经存在则不会重复插入
    28.                 cur.value = val;
    29.                 return;
    30.             }
    31.             cur = cur.next;
    32.         }
    33.         //元素没有重复，进行头插法
    34.         node.next = array[index];
    35.         array[index] = node;
    36.         usedSize++;
    37.         //计算负载因子，大于0.75则扩容
    38.         if(loadFactor() >= DEFAULT_LOAD_FACTOR) {
    39.             resize();
    40.         }
    41.     }
    42.     //扩容，即重新哈希原来的数据
    43.     private void resize() {
    44.         Node[] tmpArray = new Node[array.length * 2];//两倍扩容
    45.         //遍历原来的数组下标的每个链表，将旧数组的所有元素放到新位置上
    46.         for (int i = 0; i < array.length; i++) {
    47.             Node cur = array[i];
    48.             while (cur != null) {
    49.                 Node curNext = cur.next;//记录原来链表的下一个节点的位置
    50.                 int index = cur.key % tmpArray.length;//找到新数组的位置
    51.                 cur.next = tmpArray[index];//采用头插法放到新数组的index位置
    52.                 tmpArray[index] = cur;
    53.                 cur = curNext;//继续向后遍历
    54.             }
    55.         }
    56.         array = tmpArray;
    57.     }
    58.     //通过key值返回value
    59.     public int get(int key) {
    60.         int index = key % array.length;
    61.         Node cur = array[index];
    62.         while (cur != null) {
    63.             if(cur.key == key) {
    64.                 return cur.value;
    65.             }
    66.             cur = cur.next;
    67.         }
    68.         return -1;
    69.     }
    70.     public static void main(String[] args) {
    71.         HashBucket hashBucket = new HashBucket();
    72.         hashBucket.put(1,11);
    73.         hashBucket.put(2,22);
    74.         hashBucket.put(12,122);
    75.         hashBucket.put(3,33);
    76.         hashBucket.put(4,44);
    77.         hashBucket.put(14,144);
    78.         hashBucket.put(5,55);
    79.         hashBucket.put(16,166);
    80.         System.out.println(hashBucket.get(16));//166
    81.     }
    82. }

    若hash表中存储的就只是Integer类型的数据，上述代码完全没问题，但若是想要存放引用类型的数据，又该怎么办呢？

    5.2引用类型

    在实现引用类型哈希表之前，我们先来看看哈希表与Java类集的关系：

    1> HashMap和HashSet即Java中利用哈希表实现的Map和Set；
    2> Java会在冲突链表长度大于一定阈值后（1.链表长度大于等于8; 2.数组的大小大于等于64），链表将转变为搜索树(红黑树)；
    3> Java中计算哈希值实际上是调用类的hashCode方法，进行 key 的相等性比较是调用 key的equals方法，所以如果要用自定义类作为HashMap的key或者HashSet的值，必须重写hashCode和equals 方法，而且要做到equals相等的对象，其hashCode一定是一致的。 

    1. public class HashBuck {
    2.     static class Node {
    3.         private K key;
    4.         private V val;
    5.         private Node next;
    6.         public Node(K key, V val) {
    7.             this.key = key;
    8.             this.val = val;
    9.         }
    10.     }
    11.     public Node[] array = (Node[])new Node[10];
    12.     public int usedSize;
    13.     public HashBuck() {
    14.     }
    15.     public void put(K key,V val) {
    16.         Node node = new Node<>(key,val);
    17.         int hash = key.hashCode();
    18.         int index = hash % array.length;
    19.         Node cur = array[index];
    20.         while (cur != null) {
    21.             if(cur.key.equals(key)) {
    22.                 cur.val = val;
    23.                 return;
    24.             }
    25.             cur = cur.next;
    26.         }
    27.         node.next = array[index];
    28.         array[index] = node;
    29.         usedSize++;
    30.         //计算负载因子
    31.         //扩容
    32.     }
    33.     public V get(K key) {
    34.         int hash = key.hashCode();
    35.         int index = hash % array.length;
    36.         Node cur = array[index];
    37.         while (cur != null) {
    38.             if(cur.key.equals(key)) {
    39.                 return cur.val;
    40.             }
    41.             cur = cur.next;
    42.         }
    43.         return null;
    44.     }
    45. }
    1. import java.util.Objects;
    2.  
    3. class Person { //引用类型
    4.     public String id;
    5.     public Person(String id) {
    6.         this.id = id;
    7.     }
    8.     @Override //重写equals方法
    9.     public boolean equals(Object o) {
    10.         if (this == o) return true;
    11.         if (o == null || getClass() != o.getClass()) return false;
    12.         Person person = (Person) o;
    13.         return Objects.equals(id, person.id);
    14.     }
    15.     @Override//重写hashCode方法
    16.     public int hashCode() {
    17.         return Objects.hash(id);
    18.     }
    19.     @Override//重写toString方法
    20.     public String toString() {
    21.         return "Person{" +
    22.                 "id='" + id + '\'' +
    23.                 '}';
    24.     }
    25. }
    26. public class Test {
    27.     public static void main(String[] args) {
    28.  
    29.         Person person1 = new Person("1234");
    30.         Person person2 = new Person("1234");
    31.  
    32.         HashBuck hashBuck = new HashBuck<>();
    33.         hashBuck.put(person1, "张三");
    34.  
    35.         String name = hashBuck.get(person1);
    36.         System.out.println(name);//张三
    37.  
    38.     }
    39. }

    6.哈希表oj题 

    1）只出现一次的数字

    只出现一次的数字

    这题可以使用之前学过的异或解决，超级快，这里就用HashSet来解决了哈~

    1. public int singleNumber1(int[] nums) {
    2.     Set set = new HashSet<>();
    3.     for (int i = 0; i < nums.length; i++) {
    4.         if (set.contains(nums[i])) {
    5.             set.remove(nums[i]);
    6.         }else {
    7.             set.add(nums[i]);
    8.         }
    9.     }
    10.     for (int i = 0; i < nums.length; i++) {
    11.         if (set.contains(nums[i])) {
    12.             return nums[i];
    13.         }
    14.     }
    15.     return -1;
    16. }

    2）复制带随机指针的链表

    复制带随机指针的链表

    1. public Node copyRandomList(Node head) {
    2.     //第一遍遍历，将原来所有的元素重新new一个节点，放入map中
    3.     Map map = new HashMap<>();
    4.     Node cur = head;
    5.     while(cur != null) {
    6.         Node node = new Node(cur.val);
    7.         map.put(cur,node);
    8.         cur = cur.next;
    9.     }
    10.     //第一遍遍历完成，此时需要遍历第2遍来修改next和random的值
    11.     cur = head;
    12.     while(cur != null) {
    13.         map.get(cur).next = map.get(cur.next);
    14.         map.get(cur).random = map.get(cur.random);
    15.         cur = cur.next;
    16.     }
    17.     return map.get(head);
    18. }

    3）石与石头

    宝石与石头

    1. public int numJewelsInStones(String jewels, String stones) {
    2.     Set set = new HashSet<>();
    3.     for (int i = 0; i < jewels.length(); i++) {
    4.          char ch = jewels.charAt(i);
    5.          set.add(ch);
    6.      }
    7.      int count = 0;
    8.      for (int i = 0; i < stones.length(); i++) {
    9.          char ch = stones.charAt(i);
    10.          if (set.contains(ch)) {
    11.              count++;
    12.          }
    13.      }
    14.      return count;
    15. }

    4）坏键盘打字

    坏键盘打字

    1. /**
    2.  * @param str1 应该输入的
    3.  * @param str2 实际输入的
    4.  */
    5.  
    6. public static void func(String str1, String str2) {
    7.     Set set = new HashSet<>();
    8.     for (char ch:str2.toUpperCase().toCharArray()) {
    9.         set.add(ch);
    10.     }
    11.     Set setBroken = new HashSet<>();
    12.     for (char ch: str1.toUpperCase().toCharArray()) {
    13.         if (!set.contains(ch) && !setBroken.contains(ch)) {
    14.             setBroken.add(ch);
    15.             System.out.println(ch);
    16.         }
    17.     }
    18. }
    19. public static void main(String[] args) {
    20.     func("7_This_is_a_test","_hs_s_a_es");
    21. }

    5）前k个高频单词

    前k个高频单词

    1. public static List topKFrequent(String[] words, int k) {
    2.     //1.求每个单词出现的次数
    3.     Map map = new HashMap<>();
    4.     for(String s : words) {
    5.         if(map.get(s) == null) {
    6.             map.put(s,1);
    7.         }else {
    8.             //以前有这个元素了
    9.             int val = map.get(s);
    10.             map.put(s,val+1);
    11.         }
    12.     }
    13.     //2.统计完毕，创建小根堆
    14.     PriorityQueue> minHeap = new PriorityQueue<>(new Comparator>() {
    15.         @Override
    16.         public int compare(Map.Entry o1, Map.Entry o2) {
    17.             if(o1.getValue().compareTo(o2.getValue()) == 0) {
    18.                 return o2.getKey().compareTo(o1.getKey());//根据字母顺序,变成大根堆
    19.             }
    20.             return o1.getValue().compareTo(o2.getValue());
    21.         }
    22.     });
    23.     //3.遍历Map
    24.     for(Map.Entry entry : map.entrySet()) {
    25.         if(minHeap.size() < k) {
    26.             minHeap.offer(entry);
    27.         }else {
    28.             Map.Entry top = minHeap.peek();
    29.             if(top.getValue().compareTo(entry.getValue()) == 0) {
    30.                 //频率相同的情况下,比较key值,key值小的入
    31.                 if(top.getKey().compareTo(entry.getKey()) > 0) {
    32.                     //出top,入entry
    33.                     minHeap.poll();
    34.                     minHeap.offer(entry);
    35.                 }
    36.             }else {
    37.                 if(top.getValue().compareTo(entry.getValue()) < 0) {
    38.                     minHeap.poll();
    39.                     minHeap.offer(entry);
    40.                 }
    41.             }
    42.         }
    43.     }
    44.     //4.把小根堆里面的元素拿出来放到一个集合里面,然后逆置
    45.     List ret = new ArrayList<>();
    46.     for (int i = 0; i < k; i++) {
    47.         String s = minHeap.poll().getKey();
    48.         ret.add(s);
    49.     }
    50.     Collections.reverse(ret);
    51.     return ret;
    52. }

  • 相关阅读:
    未在本地计算机上注册“Microsoft .ACE. OLEDB .12.0”提供程序
    Pydantic：数据类型确认和解析神器
    stable diffusion上安装数字人sadtalker插件
    解决：AttributeError: ‘WebDriver‘ object has no attribute ‘find_element_by_xpath‘
    推荐一款图表功能强大的可视化报表工具
    云服务器Centos8.2SSH登陆、安装部署图形化界面以及VNC连接一文详解
    SettingsProvider
    电力电子转战数字IC20220819day64——uvm实战1A
    GBDT（梯度提升树 Gradient Boosting Decison Tree）学习笔记
    我的面试（1年经验）
  • 原文地址：https://blog.csdn.net/qq_74455045/article/details/132743572