刷题笔记之哈希表

最新推荐文章于 2021-10-13 09:47:10 发布

zhb2go

最新推荐文章于 2021-10-13 09:47:10 发布

阅读量215

点赞数

分类专栏：力扣刷题文章标签：数据结构哈希表

本文链接：https://blog.csdn.net/a1244664276/article/details/117387425

版权

这篇博客详细介绍了哈希表的概念、设计原理以及如何在Java中使用哈希集合和哈希映射。通过分析哈希函数、哈希碰撞以及冲突解决策略，博主分享了705.设计哈希集合和706.设计哈希映射的解题思路。此外，还展示了如何使用哈希表解决多种算法题，包括查找不重复元素、计算交集和判断快乐数等问题。

摘要由CSDN通过智能技术生成

前言

本博客是对哈希表做相关练习时所做笔记，主要内容来源哈希表。

原理与设计

什么是哈希表？

哈希表是一种使用哈希函数组织数据，以支持快速插入和搜索的数据结构，它根据关键码的值而直接访问元素。

当我们遇到了要快速判断一个元素是否出现在集合里的时候，就要考虑哈希法。

举例来讲，数组就是一张哈希表，哈希表中关键码就是数组的索引下表，然后通过下表直接访问数组中的元素。

哈希表主要包括两种类型：哈希集合(set)和哈希映射(map)，这在Java中都有对应的实现。
哈希函数

哈希表的关键思想是使用哈希函数将键映射到存储桶，即将键值映射为一个哈希值。如下图：

当我们插入一个新键时，哈希函数将决定该键应该分配到哪个桶中，并将该键存储在相应的桶中；

当我们想要搜索一个键时，哈希表将使用相同的哈希函数来查找对应的桶，并只在特定的桶中进行搜索。

因此，哈希函数的设计是一个关键的问题。其思想是尽可能将键分配到桶中，理想情况下，完美的哈希函数将是键和桶之间的一对一映射。
哈希碰撞

然而，在大多数情况下，哈希函数并不完美，比如键值数量大于桶的数量时，必有多个键分配到同一个桶中，这就产生了冲突。

哈希碰撞也叫哈希冲突，就是指多个键值分配到同一个桶发生冲突的现象。因此，我们也要设计合理的冲突解决算法。

冲突解决算法应该解决以下几个问题：
1. 如何组织在同一个桶中的值？
2. 如果为同一个桶分配了太多的值，该怎么办？
3. 如何在特定的桶中搜索目标值？
下面介绍两种冲突解决算法：
1. 链地址法：为每个哈希值(桶)维护一个链表，并将具有相同哈希值的元素都放入这一链表当中。
2. 开放地址法：当发现哈希值 h处产生冲突时，根据某种策略，从 h出发找到下一个不冲突的位置。例如，一种最简单的策略是，不断地检查 h+1,h+2,h+3,… 这些整数对应的位置。

705.设计哈希集合

题目描述：不使用任何内建的哈希表库设计一个哈希集合（HashSet）。

实现 MyHashSet 类：

void add(key)向哈希集合中插入值 key。
bool contains(key)返回哈希集合中是否存在这个值 key。
void remove(key)将给定值key 从哈希集合中删除。如果哈希集合中没有这个值，什么也不做。

提示：0 <= key <= 106
分析

前面说过，设计哈希表的关键就在于哈希函数的设计与哈希冲突的解决。

由于key值范围一定，此题最简单的做法就是直接初始化一个1000001大小的数组，用数组索引作为key值，这样相当于key值与哈希值一一对应。

比较规范的做法就是分别设计哈希函数与冲突解决方法。

参考力扣官方题解，哈希函数：hash(x)=x mod base，为了尽可能避免冲突，应当将 base 取为一个质数。在这里，我们取 base=769。

对于冲突解决办法使用链地址法，开辟一个大小为 base 的数组，数组的每个位置是一个链表。当计算出哈希值之后，就插入到对应位置的链表当中。

代码

class MyHashSet {
     
    private static final int BASE = 769;
    //数组的每个位置是一个链表
    private LinkedList<Integer>[] data;
    /** Initialize your data structure here. */
    public MyHashSet() {
     
        data = new LinkedList[BASE];
        //初始化对象
        for(int i=0; i<BASE; i++) {
     
            data[i] = new LinkedList<Integer>();
        }
    }
    
    public void add(int key) {
     
        //根据散列函数找到要插入的位置
        int h = hash(key);
        //遍历data[h],判断该位置上是否已经有该键
        for(Integer k : data[h]){
     
            if(k == key) return;
        }
        //若没有就插入到最后
        data[h].add(key);
    }
    
    public void remove(int key) {
     
        //根据散列函数找到要删除key的位置
        int h = hash(key);
        //遍历data[h],判断该位置上是否有该键
        for(Integer k : data[h]){
     
            //如果有就直接删除
            if(k == key) {
     
                data[h].remove(k);
                return;
            }
        }
    }
    
    /** Returns true if this set contains the specified element */
    public boolean contains(int key) {
     
        //根据散列函数找到key的位置
        int h = hash(key);
        //遍历data[h],判断该位置上是否有该键
        for(Integer k : data[h]){
     
            //如果有就直接删除
            if(k == key) return true;
        }
        return false;
    }

    //哈希函数
    public int hash(int key) {
     
        return key % BASE;
    }
}

/**
 * Your MyHashSet object will be instantiated and called as such:
 * MyHashSet obj = new MyHashSet();
 * obj.add(key);
 * obj.remove(key);
 * boolean param_3 = obj.contains(key);
 */

706.设计哈希映射

题目描述：不使用任何内建的哈希表库设计一个哈希映射（HashMap）。

实现 MyHashMap 类：

MyHashMap() 用空映射初始化对象
void put(int key, int value) 向 HashMap 插入一个键值对 (key, value) 。如果 key 已经存在于映射中，则更新其对应的值 value 。
int get(int key) 返回特定的 key 所映射的 value ；如果映射中不包含 key 的映射，返回 -1 。
void remove(key) 如果映射中存在 key 的映射，则移除 key 和它所对应的 value 。
分析

与上题一样，只不过把key值换成了(key,value)，可以单独设计一个类，来存放(key,value)。

代码

class Pair {
     
    int key;
    int value;
    public Pair(int key, int value) {
     
        this.key = key;
        this.value = value;
    }
}

class MyHashMap {
     
    private static final int BASE = 769;
    LinkedList<Pair>[] data;
    /** Initialize your data structure here. */
    public MyHashMap() {
     
        data = new LinkedList[BASE];
        for(int i=0; i<BASE; i++) {
     
            data[i] = new LinkedList<Pair>();
        }
    }
    
    /** value will always be non-negative. */
    public void put(int key, int value) {
     
        //找到对应的哈希值
        int h = hash(key);
        //遍历data[h]，判断键值对是否已存在
        for(Pair pair : data[h]) {
     
            //键值对已存在，就直接更新
            if(pair.key == key) {
     
                pair.value = value;
                return;
            }
        }
        //键值对不存在，插在链表头
        data[h].add(new Pair(key,value));
    }
    
    /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
    public int get(int key) {
     
        //找到对应的哈希值
        int h = hash(key);
        //遍历data[h]，判断键值对是否已存在
        for(Pair pair : data[h]) {
     
            //键值对已存在，返回对应的值
            if(pair.key == key) {
     
                return pair.value;
            }
        }
        return -1;
    }
    
    /** Removes the mapping of the specified value key if this map contains a mapping for the key */
    public void remove(int key) {
     
        //找到对应的哈希值
        int h = hash(key);
        //遍历data[h]，判断键值对是否已存在
        for(Pair pair : data[h]) {
     
            //键值对已存在，删除
            if(pair.key == key) {
     
                data[h].remove(pair);
                return;
            }
        }
    }

    public int hash(int key) {
     
        return key % BASE;
    }
}

哈希集合

哈希集合是集合的实现之一，它是一种存储不重复值的数据结构。

Java中HashSet的基本使用

public class Test {
   
    public static void main(String[] args) {
   
        Set<Integer> set = new HashSet<>();
        //添加操作，所添加的key不存在返回true，已存在返回false
        set.add(2);
        set.add(4);
        set.add(6);
        //删除操作，删除key
        set.remove(2);
        //foreach迭代
        for(Integer key : set) {
   
            System.out.println(key);
        }
        //迭代器迭代
        Iterator<Integer> iterator = set.iterator();
        while(iterator.hasNext()) {
   
            System.out.println(iterator.next());
        }
        //集合大小
        int size = set.size();
        System.out.println(size);
        //判断key是否存在
        System