数据结构——散列表

Dear 丶 2024-02-18 12:30 13阅读 0赞

> 参考书籍：
> 
>  *  《数据结构与抽象：Java语言描述》 第四版

## 一、背景知识 ##

>  *  散列（hashing）：是仅利用项的查找键，无需查找就可确定其下标的一项技术
>  *  散列表（hash table）：数组
>  *  散列索引（hash index）：下标
>  *  散列函数（hash function）：根据查找键得到元素在散列表中的整数下标
>     
>      *  查找键映射（map）或散列（hash）到下标
>  *  散列函数使用hashCode()方法从查找键来计算散列码（hash code），然后将散列码压缩为散列表的地址。
>     
>      *  散列码：c；
>      *  散列表的位置个数：n；（大于2的素数）
>      *  c%n 在0~n-1之间
>      *  c%n 是有n个位置的散列表的理想下标
>  *  对象不equals，散列码就不同。
>  *  冲突（collision）：多个查找键映射到散列表中的同一个位置
>  *  冲突解决方案（collision resolution）：
>     
>      *  1、开放地址法
>         
>          *  （1）线性探查（linear probing）：检查散列表中的连续位置，从原始散列地址开始，每次的增量为1，直到找到下一个可用的位置
>             
>              *  出现的问题：基本聚集（primary clustering），即散列表中一组组（簇，cluster）连续的位置被占用
>              *  优点：能够到达散列表的每个位置
>          *  （2）二次探查（quadratic probing）：从最初的散列地址 ![k][] 开始，每次的增量为![j^\{2\}(j\\geq 0)][j_2_j_geq 0]，检查地址为![k+j^\{2\}(j\\geq 0)][k_j_2_j_geq 0]的位置。![fa60fd8b2b0c442d810b6dca091e31a6.png][]
>             
>              *  如果探查序列到达散列表的表尾，它会绕回到表的开头。越到序列的后面距离增量会越大
>              *  出现的问题：通过检查散列表中最初的散列地址加上![j^\{2\}(j\\geq 0)][j_2_j_geq 0]的位置，避免了基本聚集，但可能会导致二级聚集（增加了探查序列的长度）
>          *  （3）双散列（double hashing）：检查散列表中最初的散列地址加上由第二个散列函数定义的增量的位置
>             
>              *  优点：避免了基本聚集和二级聚集
>      *  2、拉链法
>         
>          *  桶（bucket）：每个位置可以表示多个值，多用链式结构，因为可以给桶按需分配内存
>          *  散列表的每个位置都是一个个链式桶，先散列查找键，然后在链式桶里查找键-值对。如果允许重复键，就把新项添加到链头，否则遍历链式桶，添加到链尾。
>          *  ![f5a2884838b4407e8881428a003d536f.jpeg][]
>          *  改变了散列表的结构
>  *  散列表：
>     
>      *  时间复杂度![O(1)][O_1]

## 二、（Hash Table） ##

老东西，现在不咋用了

## 三、**哈希映射（Hash Map）** ##

//哈希映射常用方法：
    Map<T,T> map=new HashMap<>();//创建一个哈希映射
    map.clear();//清空哈希映射
    map.containsKey(key);//是否包括元素key，返回boolean值
    map.containsValue(value);//是否包括元素value，返回boolean值
    map.get(key);//返回键key对应的值value
    map.isEmpty();//哈希映射是否为空，返回boolean值
    map.put(key,value);//把键值对存入哈希映射
    map.remove(key);//移除key这对键值对
    map.size();//获取哈希映射的大小
    map.getOrDefault(key,value);//如果map中包含key，就获取对应的值，否则返回value

哈希集合的遍历方式：

import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    
    public class Test {
        public static void main(String[] args) {
            HashMap<String, String> hashMap = new HashMap<>();
            hashMap.put("1","value1");
            hashMap.put("2","value2");
            hashMap.put("3","value3");
            hashMap.put("4","value4");
            hashMap.put("5","value5");
            hashMap.put("6","value6");
    
            /**
             *  第一种遍历方式，采用for遍历key值，然后通过key去获取hashmap中的数据
             */
            for (String key:hashMap.keySet()) {
                System.out.println("key: " + key + " value: " + hashMap.get(key));
            }
    
            /**
             * 第二种遍历方式，采用Iterator 把hashmap中的数据放到迭代器中，然后用while循环把迭代器中的数据都读出来
             */
            Iterator iterator = hashMap.entrySet().iterator();
            while(iterator.hasNext()) {
                Map.Entry<String, String> entry=(Map.Entry<String, String>) iterator.next();
                System.out.println("Key: "+entry.getKey()+" Value: "+entry.getValue());
            }
    
            /**
             * 第三种遍历方式，采用for循环遍历hashmap中的数据，使用方便，但是数据量小时好用，如果数据量大的话非常消耗性能
             */
            for(Map.Entry<String, String> entry: hashMap.entrySet()) {
                System.out.println("Key: "+ entry.getKey()+ " Value: "+entry.getValue());
            }
        }
    }

## 三、  **哈希集合（Hash Set）** ##

//哈希集合常用方法：
    Set<T> set=new HashSet<>();//创建一个T类型的哈希集合
    set.add(e);//添加元素
    set.clear();//清空哈希集合
    set.contains(e);//哈希集合中是否包含元素e，返回boolean值
    set.isEmpty();//哈希集合中是否为空，返回boolean值
    set.iterator();//返回一个迭代器
    set.remove(e);//删除元素e
    set.size();//获取哈希集合的大小
    set.toArray();//返回一个包含哈希集合所有元素的数组

> <table> 
>  <thead> 
>   <tr> 
>    <th>HashTable</th> 
>    <th><code>HashMap</code></th> 
>    <th><code>HashSet</code></th> 
>   </tr> 
>  </thead> 
>  <tbody> 
>   <tr> 
>    <td>实现了接口<code>Map</code></td> 
>    <td>实现了接口<code>Map</code></td> 
>    <td>实现了接口Collection</td> 
>   </tr> 
>   <tr> 
>    <td>存储键值对</td> 
>    <td>存储键值对</td> 
>    <td>仅存储对象（元素）</td> 
>   </tr> 
>   <tr> 
>    <td>线程安全</td> 
>    <td>线程不安全</td> 
>    <td>线程不安全</td> 
>   </tr> 
>   <tr> 
>    <td>不允许键或值为null，且不保证元素顺序</td> 
>    <td>允许键和值为null，但不保证元素顺序，且键不可重复</td> 
>    <td>允许值为null，但不保证元素顺序，且元素不可重复</td> 
>   </tr> 
>   <tr> 
>    <td></td> 
>    <td></td> 
>    <td> <p></p> </td> 
>   </tr> 
>  </tbody> 
> </table>

## 四、例题 ##

### 1、两数之和 ###

![16b326c2d2dd4d898c2403ddc283a0ad.png][]

方法一：双重for循环

class Solution {
        public int[] twoSum(int[] nums, int target) {
            int[] arr=new int[2];//把结果存入数组中返回
            for(int i=0;i<nums.length-1;i++){
                for(int j=i+1;j<nums.length;j++){
                    if(nums[i]+nums[j]==target){
                        arr[0]=i;
                        arr[1]=j;
                        break;
                    }
                }
            }
            return arr;
        }
    }

![47e78aa9476f4e3188f98dbab4511399.png][]

#### 方法二：哈希表 ####

class Solution {
        public int[] twoSum(int[] nums, int target) {
            int[] arr=new int[2];
            Map<Integer,Integer> ht=new HashMap<>();//创建一个哈希表
            for(int i=0;i<nums.length;i++){
                if(ht.containsKey(target-nums[i])){
                    arr[0]=i;
                    arr[1]=ht.get(target-nums[i]);//键
                    break;
                }
                ht.put(nums[i],i);//哈希表的键：数组元素；值：数组元素下标
            }
            return arr;
        }
    
    }
    /**
    思路：
    1、在哈希表中查找target-x
    2、如果哈希表中不存在target-x，再将x插入哈希表中，即可保证x不会和自己匹配
     */

![d99e3906dbbe465f9633d1010621cbc0.png][]

进一步优化：(去掉数组后，降低了时间复杂度)

class Solution {
        public int[] twoSum(int[] nums, int target) {
            Map<Integer,Integer> ht=new HashMap<>();//创建一个哈希表
            for(int i=0;i<nums.length;i++){
                if(ht.containsKey(target-nums[i])){
                    return new int[]{i,ht.get(target-nums[i])};
                }
                ht.put(nums[i],i);//哈希表的键：数组元素；值：数组元素下标
            }
            return new int[0];
        }
    
    }
    /**
    思路：
    1、在哈希表中查找target-x
    2、如果哈希表中不存在target-x，再将x插入哈希表中，即可保证x不会和自己匹配
     */

![e040b13930184e628695701f432ae638.png][]

### 2、字母异位词分组 ###

![f1554c6ab7d748bf843d809412341787.png][] 方法一：哈希表

class Solution {
        public List<List<String>> groupAnagrams(String[] strs) {
            List<List<String>> list1=new ArrayList<>();
            Map<String,List<String>> hashtable=new HashMap<>();
            //遍历数组，存下标进哈希表
            for(int i=0;i<strs.length;i++){
                //对单词进行重排序
                char[] c=strs[i].toCharArray();
                Arrays.sort(c);
                String s=new String(c);
                //String s=c.toString();
                if(!hashtable.containsKey(s)){//哈希表中未出现这种字母组合
                    List<String> list3=new ArrayList<>();
                    list3.add(strs[i]);
                    hashtable.put(s,list3);
                }else{//哈希表中已有这种字母组合，直接添加单词进去，更新list3
                    hashtable.get(s).add(strs[i]);//相当于list3.add(strs[i]);
                }
            }
            //遍历哈希表，存单词进链表
            for(String key:hashtable.keySet()){
                list1.add(hashtable.get(key));
            }
            return list1;
        }
    }
    /**
    思路：
    把单词按字母顺序重新排序后，存入哈希表中，当键
    遍历哈希表，取出值（一条条链表list3）存入链表list1中返回
     */

![78cf0f92cf3e4181be58ffdd2d0828f7.png][]

![e28e76886d284a12a9c28eafb63da98d.jpeg][]

简洁化代码：

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);
                //如果哈希表中的key存在，就调用map.get(key)方法，返回值 
                //如果不存在，就返回new ArrayList<String>()，创建新链表
                List<String> list = map.getOrDefault(key, new ArrayList<String>());
                list.add(str);
                map.put(key, list);
            }
            //把哈希表里的值取出存入新链表返回
            return new ArrayList<List<String>>(map.values());
        }
    }
    //哈希表的键为一组字母异位词的标志，哈希表的值为一组字母异位词列表。

### 3、最长连续序列 ###

![e69f644008cb44b69ebfbc3b3c9ab077.png][]

方法一：普通遍历

class Solution {
        public int longestConsecutive(int[] nums) {
            if(nums.length==0){
                return 0;
            }
            Arrays.sort(nums);//对原数组进行排序
            int len=1;//连续序列长度
            int m=1;//最大值 
            if(nums.length>1){
                for(int i=0;i<nums.length-1;i++){
                    if(nums[i+1]-nums[i]==1){//元素是连续
                        len++;//长度加一
                        m=Math.max(m,len);//维护一个最大值 
                    }else if(nums[i+1]-nums[i]>1){//元素不连续
                        len=1;//连续序列长度重置为0，继续搜寻下一组连续序列
                    }    
                }
            }
            return m;
        }
    }
    /**
    思路：
    1、对原数组进行排序
    2、遍历原数组，维护一个序列长度的最大值 
     */

![824b6a69a7554f4ba8fcd23c8b28e434.png][]

#### 方法二：哈希表 ####

> 考察了hashset的contains()方法查找元素和其元素的无序性

class Solution {
        public int longestConsecutive(int[] nums) {
            Set<Integer> num_set = new HashSet<Integer>();
            for (int num : nums) {//用哈希表存储数组元素，去重（哈希集合不能存储相同的元素）
                num_set.add(num);
            }
            int longestStreak = 0;//最长序列长度
            for (int num : num_set) {//遍历哈希表
                if (!num_set.contains(num - 1)) {//当前值不存在前驱，要么它是连续序列中的第一个元素，要么它不在连续序列，跳过
                    int currentNum = num;
                    int currentStreak = 1;
    
                    while (num_set.contains(currentNum + 1)) {//当前值存在前驱，进入内层循环，去匹配该组连续序列的数，
                        currentNum += 1;
                        currentStreak += 1;
                    }
    
                    longestStreak = Math.max(longestStreak, currentStreak);//维护一个最大值 
                }
            }
    
            return longestStreak;
        }
    }

![25e2a5e269a8493bb0ce8578def6b280.png][]

[k]: https://latex.csdn.net/eq?k
[j_2_j_geq 0]: https://latex.csdn.net/eq?j%5E%7B2%7D%28j%5Cgeq%200%29
[k_j_2_j_geq 0]: https://latex.csdn.net/eq?k&plus;j%5E%7B2%7D%28j%5Cgeq%200%29
[fa60fd8b2b0c442d810b6dca091e31a6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/91466f52af8f43c78c1a91518656c2f0.png
[f5a2884838b4407e8881428a003d536f.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/5170e7a1969741b8a8cf23094682c347.png
[O_1]: https://latex.csdn.net/eq?O%281%29
[16b326c2d2dd4d898c2403ddc283a0ad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/71240f5d075944239e45b745ac4f1985.png
[47e78aa9476f4e3188f98dbab4511399.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/f0adce1e4e354678bf67784a8aaffa59.png
[d99e3906dbbe465f9633d1010621cbc0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/6934eec43f004a34be0fc242bb2d5687.png
[e040b13930184e628695701f432ae638.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/48cdbb71104a4bbca9db162b71b8efbf.png
[f1554c6ab7d748bf843d809412341787.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/685c8d9d81664f2694dedec881ffe19a.png
[78cf0f92cf3e4181be58ffdd2d0828f7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/75ec1b4b7cc140f1aa891f459bd17b22.png
[e28e76886d284a12a9c28eafb63da98d.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/a4f81d94b8c0438a91626a68ebf7538b.png
[e69f644008cb44b69ebfbc3b3c9ab077.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/aa8626c5f8934ce18ff1789c5833d7ac.png
[824b6a69a7554f4ba8fcd23c8b28e434.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/16a4364b0c1449289cbc9db136ea1b68.png
[25e2a5e269a8493bb0ce8578def6b280.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/4575aca08973498aa3362ef8f703e5e2.png