玩转数据结构(21)-- 哈希表

最新推荐文章于 2024-12-07 19:52:39 发布
原创 最新推荐文章于 2024-12-07 19:52:39 发布 · 501 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了哈希表的基础知识，包括哈希函数设计、Java中的hashCode方法和哈希冲突处理，特别是链地址法。文章还探讨了自定义哈希表的实现、动态空间处理以及更复杂的冲突解决策略，旨在帮助读者深入理解哈希表的工作原理和优化技巧。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

哈希表

一、哈希表基础

从习题入手【题目链接】

思路：可以不使用树结构来实现映射，可以直接设置包含 26个 元素的数组，对数组中每一位表示某一个字符对应的频率即可；索引为 0 的位置表示 a ，索引为 1 的位置表示 b ，以此类推。

哈希表定义：把所关心的键通过哈希函数转换为索引，然后直接把内容存在数组中即可

代码：

class Solution {
    public int firstUniqChar(String s) {

        int[] freq = new int[26];
        for(int i = 0 ; i < s.length() ; i ++)
            freq[s.charAt(i) - 'a'] ++;

        for(int i = 0 ; i < s.length() ; i ++)
            if(freq[s.charAt(i) - 'a'] == 1)
                return i;

        return -1;
    }
}

输出：

int[26] freq 就是一个哈希表，每一个字符都和一个索引相对应

哈希表要解决的关键问题：1.哈希函数的设计 2.  如何解决哈希冲突   【核心思想：空间换时间；哈希表是时间和空间之间的平衡】

哈希表就是一种以 键-值(key-indexed) 存储数据的结构，我们只要输入待查找的值即key，即可查找到其对应的值。【详解】

哈希的思路很简单，如果所有的键都是整数，那么就可以使用一个简单的无序数组来实现：将键作为索引，值即为其对应的值，这样就可以快速访问任意键的值。这是对于简单的键的情况，我们将其扩展到可以处理更加复杂的类型的键。

使用哈希查找有两个步骤:

  1. 使用哈希函数将被查找的键转换为数组的索引。在理想的情况下，不同的键会被转换为不同的索引值，但是在有些情况下我们需要处理多个键被哈希到同一个索引值的情况。所以哈希查找的第二个步骤就是处理冲突
  2. 处理哈希碰撞冲突。有很多处理哈希碰撞冲突的方法，如拉链法和线性探测法。

哈希表是一个在时间和空间上做出权衡的经典例子。如果没有内存限制，那么可以直接将键作为数组的索引。那么所有的查找时间复杂度为O(1)；如果没有时间限制，那么我们可以使用无序数组并进行顺序查找，这样只需要很少的内存。哈希表使用了适度的时间和空间来在这两个极端之间找到了平衡。只需要调整哈希函数算法即可在时间和空间上做出取舍。

二、哈希函数的设计

“键” 通过哈希函数得到的 “索引” 分布越均匀越好

1.整型

小范围正整数直接使用

小范围负整数进行偏移

大整数：

2.浮点型

在计算机中都是 32位 或 64位 的二进制表示，只不过计算机解析成了浮点数

 

转成整型处理，再用前面的 取模 方法来处理

3.字符串

方法：转成 整型 处理

4.复合类型

方法：转成 整型 处理

哈希函数设计原则：、

1.一致性：如果 a == b , 则 hash(a) == hash(b)

2.高效性：计算高效简便

3.均匀性：哈希值均匀分布

三、Java中的 hashCode 方法

查看 Java 中不同类型的哈希值计算方法

Main.java

import java.util.HashSet;
import java.util.HashMap;

public class Main {

    public static void main(String[] args) {

        int a = 42;
        System.out.println(((Integer)a).hashCode());

        int b = -42;
        System.out.println(((Integer)b).hashCode());

        double c = 3.1415926;
        System.out.println(((Double)c).hashCode());

        String d = "imooc";
        System.out.println(d.hashCode());

        System.out.println(Integer.MAX_VALUE + 1);
        System.out.println();

        Student student = new Student(3, 2, "Bobo", "Liu");
        System.out.println(student.hashCode());

        HashSet<Student> set = new HashSet<>();
        set.add(student);

        HashMap<Student, Integer> scores = new HashMap<>();
        scores.put(student, 100);

        Student student2 = new Student(3, 2, "Bobo", "Liu");
        System.out.println(student2.hashCode());
    }
}

自定义类：Student.java

public class Student {	//复合的数据类型

    int grade;
    int cls;
    String firstName;
    String lastName;

    Student(int grade, int cls, String firstName, String lastName){
        this.grade = grade;
        this.cls = cls;
        this.firstName = firstName;
        this.lastName = lastName;
    }

    @Override
    public int hashCode(){

        int B = 31;
        int hash = 0;
        hash = hash * B + ((Integer)grade).hashCode();
        hash = hash * B + ((Integer)cls).hashCode();
        hash = hash * B + firstName.toLowerCase().hashCode();
        hash = hash * B + lastName.toLowerCase().hashCode();
        return hash;
    }

    @Override
    public boolean equals(Object o){

        if(this == o)
            return true;

        if(o == null)
            return false;

        if(getClass() != o.getClass())
            return false;

        Student another = (Student)o;
        return this.grade == another.grade &&
                this.cls == another.cls &&
                this.firstName.toLowerCase().equals(another.firstName.toLowerCase()) &&
                this.lastName.toLowerCase().equals(another.lastName.toLowerCase());
    }
}

输出：

四、哈希冲突的处理--链地址法 (Seperate Chaining)

1.将 元素k1 转换为 哈希表中对应的索引值

2.假如计算后 k1 的索引对应是 4 的话，在哈希表索引为 4 的位置存储 k1

3.再加入元素 k2 ，则用相同的方法计算出索引值 为 1，插入到哈希表中

4.再加入元素 k3 ，则用相同的方法计算出索引值 为 1，产生哈希冲突，但仍然将其插入到哈希表中，将其作为 链表 即可

链地址法：对整个哈希表，开辟 m 个空间，对于每一个空间，由于有哈希冲突的存在，其本质上都是存储 一个链表（查找表），查找表的底层实现不一定是链表，也可以使用树结构，如图

（HashMap 本质就是一个 TreeMap 数组 / HashSet 本质就是一个 TreeSet 数组）

【Java8 之前，每一个位置对应一个链表，Java8 开始，当哈希冲突达到一定程度，每一个位置从链表转成红黑树】

五、实现属于我们自己的哈希表

代码实现：

HashTable.java

import java.util.TreeMap;

public class HashTable<K, V> {

    private TreeMap<K, V>[] hashtable;
    private int size;
    private int M;

    public HashTable(int M){
        this.M = M;
        size = 0;
        hashtable = new TreeMap[M];
        for(int i = 0 ; i < M ; i ++)
            hashtable[i] = new TreeMap<>();
    }

    public HashTable(){
        this(97);
    }

    private int hash(K key){
        return (key.hashCode() & 0x7fffffff) % M;
    }

    public int getSize(){
        return size;
    }

    public void add(K key, V value){  //增
        TreeMap<K, V> map = hashtable[hash(key)];
        if(map.containsKey(key))
            map.put(key, value);
        else{
            map.put(key, value);
            size ++;
        }
    }

    public V remove(K key){     //删
        V ret = null;
        TreeMap<K, V> map = hashtable[hash(key)];
        if(map.containsKey(key)){
            ret = map.remove(key);
            size --;
        }
        return ret;
    }

    public void set(K key, V value){  //改
        TreeMap<K, V> map = hashtable[hash(key)];
        if(!map.containsKey(key))
            throw new IllegalArgumentException(key + " doesn't exist!");

        map.put(key, value);
    }

    public boolean contains(K key){  //查
        return hashtable[hash(key)].containsKey(key);
    }

    public V get(K key){
        return hashtable[hash(key)].get(key);
    }
}

测试时间复杂度：Main.java

import java.util.ArrayList;

public class Main {

    public static void main(String[] args) {

        System.out.println("Pride and Prejudice");

        ArrayList<String> words = new ArrayList<>();
        if(FileOperation.readFile("pride-and-prejudice.txt", words)) {
            System.out.println("Total words: " + words.size());

            // Collections.sort(words);

            // Test BST
            long startTime = System.nanoTime();

            BST<String, Integer> bst = new BST<>();
            for (String word : words) {
                if (bst.contains(word))
                    bst.set(word, bst.get(word) + 1);
                else
                    bst.add(word, 1);
            }

            for(String word: words)
                bst.contains(word);

            long endTime = System.nanoTime();

            double time = (endTime - startTime) / 1000000000.0;
            System.out.println("BST: " + time + " s");


            // Test AVL
            startTime = System.nanoTime();

            AVLTree<String, Integer> avl = new AVLTree<>();
            for (String word : words) {
                if (avl.contains(word))
                    avl.set(word, avl.get(word) + 1);
                else
                    avl.add(word, 1);
            }

            for(String word: words)
                avl.contains(word);

            endTime = System.nanoTime();

            time = (endTime - startTime) / 1000000000.0;
            System.out.println("AVL: " + time + " s");


            // Test RBTree
            startTime = System.nanoTime();

            RBTree<String, Integer> rbt = new RBTree<>();
            for (String word : words) {
                if (rbt.contains(word))
                    rbt.set(word, rbt.get(word) + 1);
                else
                    rbt.add(word, 1);
            }

            for(String word: words)
                rbt.contains(word);

            endTime = System.nanoTime();

            time = (endTime - startTime) / 1000000000.0;
            System.out.println("RBTree: " + time + " s");


            // Test HashTable
            startTime = System.nanoTime();

            // HashTable<String, Integer> ht = new HashTable<>();
            HashTable<String, Integer> ht = new HashTable<>(131071);
            for (String word : words) {
                if (ht.contains(word))
                    ht.set(word, ht.get(word) + 1);
                else
                    ht.add(word, 1);
            }

            for(String word: words)
                ht.contains(word);

            endTime = System.nanoTime();

            time = (endTime - startTime) / 1000000000.0;
            System.out.println("HashTable: " + time + " s");
        }

        System.out.println();
    }
}

输出：

六、哈希表的动态空间处理与复杂度分析

总共有 M 个地址，如果放入哈希表的元素为 N，时间复杂度：

1.如果每个地址是链表 ：O(N/M);最坏情况：O(n)【全部发生哈希冲突】

2.如果每个地址是平衡树：O(log(N/M));最坏情况：O(log n)【全部发生哈希冲突】

如何让时间复杂度变为 O(1) :1.数组应该是动态内存分配，空间随着 n 的改变可以进行自适应（使用 resize 方法）

 resize 方法：

平均每个地址承载的元素多过一定的程度，即扩容【N/M >= upperTol】

平均每个地址承载的元素少过一定的程度，即扩容【N/M < lowerTol】

HashTable.java

import java.util.Map;
import java.util.TreeMap;

public class HashTable<K, V> {

    private static final int upperTol = 10;		//上限
    private static final int lowerTol = 2;		//下限
    private static final int initCapacity = 7;	//初始哈希表容量

    private TreeMap<K, V>[] hashtable;
    private int size;
    private int M;

    public HashTable(int M){
        this.M = M;
        size = 0;
        hashtable = new TreeMap[M];
        for(int i = 0 ; i < M ; i ++)
            hashtable[i] = new TreeMap<>();
    }

    public HashTable(){
        this(initCapacity);
    }

    private int hash(K key){
        return (key.hashCode() & 0x7fffffff) % M;
    }

    public int getSize(){
        return size;
    }

    public void add(K key, V value){
        TreeMap<K, V> map = hashtable[hash(key)];
        if(map.containsKey(key))
            map.put(key, value);
        else{
            map.put(key, value);
            size ++;

            if(size >= upperTol * M)	//超过上限，进行扩容
                resize(2 * M);
        }
    }

    public V remove(K key){
        V ret = null;
        TreeMap<K, V> map = hashtable[hash(key)];
        if(map.containsKey(key)){
            ret = map.remove(key);
            size --;

            if(size < lowerTol * M && M / 2 >= initCapacity)	//小于下限，进行缩容
                resize(M / 2);
        }
        return ret;
    }

    public void set(K key, V value){
        TreeMap<K, V> map = hashtable[hash(key)];
        if(!map.containsKey(key))
            throw new IllegalArgumentException(key + " doesn't exist!");

        map.put(key, value);
    }

    public boolean contains(K key){
        return hashtable[hash(key)].containsKey(key);
    }

    public V get(K key){
        return hashtable[hash(key)].get(key);
    }

    private void resize(int newM){
        TreeMap<K, V>[] newHashTable = new TreeMap[newM];
        for(int i = 0 ; i < newM ; i ++)
            newHashTable[i] = new TreeMap<>();

        int oldM = M;
        this.M = newM;	//注意更新M
        for(int i = 0 ; i < oldM ; i ++){
            TreeMap<K, V> map = hashtable[i];
            for(K key: map.keySet())
                newHashTable[hash(key)].put(key, map.get(key));
        }

        this.hashtable = newHashTable;
    }
}

哈希表的复杂度分析：

知哈希表均摊时间复杂度为：O(1)

代码中的Bug: Comparable(可比较性矛盾)

七、哈希表更复杂的动态空间处理方法

扩容 M--2*M ,但 2*M 可能不是 素数 了，但希望 哈希表 的空间最好是 素数；

解决方法：不要简单的 *2，而是根据下表，超过 53 就扩容为 97 ，超过 97 就扩容为 193，以此类推。

八、更多哈希冲突的处理方法

1.开放地址法

在链地址法中，每一个键计算出哈希值之后，哈希值索引所在的地址只属于所属的哈希值等于这个索引相应的元素【封闭地址】

开放地址法和上述方法相反，对于哈希表中的每一个地址，所有哈希值的元素都有机会进入

每一个地址就是直接存元素，11 和 31 产生哈希冲突，就从索引为 1 的地方向下找，空的地方是索引为 2 的地方，故将 31 放在 2 中；

再插入元素 81，发生哈希冲突，原理同上，插入到索引 3 的位置【此方法：线性探测，遇到哈希冲突 +1】

平方探测：遇到哈希冲突 +1 +4 + 9 ...【提高性能】

二次哈希：遇到哈希冲突 +hash2(key)

更多方法：

总结：

玩转数据结构——均摊复杂度和防止复杂度的震荡（笔记）
believe_s的博客
06-22 1814
数据规模 时间复杂度 并不是所有的双层循环都是O（n^2）的 复杂度实验来确定复杂度 // O(N) 两倍增加 int findMax( int arr[], int n ){ assert( n &amp;gt; 0 ); int res = arr[0]; for( int i = 1 ; i &amp;lt; n ; i ++ ) ...
玩转数据结构
weixin_39611700的博客
04-21 1397
玩转数据结构 第一课 入门第二课 不要小瞧数组2-1使用java中的数组2-2 二次封装自己的数组新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLo...
第三十四篇 玩转数据结构——哈希表（HashTable）
weixin_30352645的博客
07-14 108
1.. 整型哈希函数的设计 小范围正整数直接使用 小范围负整数整体进行偏移 大整数，通常做法是"模一个素数" 2.. 浮点型哈希函数的设计 ...
chenyongzhe#programming-data#玩转数据结构00-概述1
07-25
数据结构可以分为三类线性结构数组、栈队列、链表哈希表树结构二叉树、二分搜索树并查集、哈夫曼树图结构邻接矩阵邻接表数据结构无处不在数据结构是算法的基石。数据结构
玩转数据结构.zip........
04-07
在“玩转数据结构”这个主题中，我们可以深入探讨一系列关键的数据组织方式，这些方式对于编写高效的算法至关重要。 1. **数组**：数组是最基本的数据结构，它是一个相同类型元素的有序集合。在数组中，可以通过索...
数据结构进阶(C++) -- 哈希表的模拟实现
最新发布
zy1215058242的博客
12-07 1278
在类模板内部通过。
玩转数据结构 从入门到进阶
10-24
《玩转数据结构 从入门到进阶》这本书旨在为读者提供一个系统学习数据结构的途径，涵盖了从基础知识到高级应用的多个方面。 #### 二、数据结构基础知识 ##### 2.1 数组 数组是最基本的数据结构之一，它通过索引来...
哈希表设计 严蔚敏 数据结构习题册
04-17
完全按照严蔚敏的数据结构习题册上的要求写的
玩转数据结构（一）玩转数据结构介绍
sinat_38368658的博客
06-26 353
为什么要学习数据结构 数据结构研究的 是数据如何在计算机中进行组织和存储，使得我们可以高效的获取数据或者修改数据。 在计算机的世界中，数据结构无处不在。 数据结构+算法=程序 课程设置 面向基础：递归，调试，复杂度分析 手把手的底层实现，创建属于自己的小型数据结构库 强调比较和优化 面向面试（前六个DS数组，栈，队列，链表，二分搜索树，堆，线段树，Trie更为重要，达到白板编...
数据结构之哈希表
清文的博客
02-10 743
具体介绍见MIT算法导论-第7,8讲-哈希表Java 集合之 HashMap详细介绍(源码解析)和使用示例HashMap详细介绍(源码解析)和使用示例下面给出两种实现1.基于拉链法的散列表package xwq.dt;import xwq.util.StdIn; import xwq.util.StdOut;public class SeparateChainingHashST<Key,Value>
【玩转数据结构Part1】数组/栈/队列/链表
aaon22357的博客
07-07 457
来自于慕课网上的教学课程《玩转数据结构》笔记 https://coding.imooc.com/class/71.html，该视频一共讲解了十二个数据结构。包括： 数组 栈 队列 链表 二分搜索树 堆 线段树 Trie 并查集 AVL 红黑树 哈希表 本课程不包含图结构，因为图论领域以算法为主。 面试常考的：前六个数据结构（要做到白板编程的水平） 面向竞赛：7，8，9 最后三个：面试常考，但由...
玩转数据结构从入门到进阶（四 集合set与映射map堆与优先队列，线段树：）
sinat_36748650的博客
04-16 562
项目源码：https://gitee.com/renqiqi/shujvjiegou 层序遍历：广度优先遍历 使用非递归方式实现。更快的找到想要的元素，主要应用于搜索。 删除任意节点：删除节点后，找到该节点的右子树中最小值，让他顶替该节点的位置，并在原来的位置上删除这个最 小值 用链表来实现set集合复杂度是O(n)，而用二分搜索树来实现Set，复杂度是O（logn）：其实是O(h)，h就是树的高...
【数据结构/哈希表】题解+详细备注（共11题）
MichaelKongChina的博客
04-09 1800
通过11题的训练：掌握STL序列容器以及关联式容器的使用 242.有效的字母异位词 383.赎金信 49.字母异位词分组 438.找到字符串中所有字母异位词 349.两个数组的交集 350.两个数组的交集II 202.快乐数 1.两数之和 454.四数相加II 15.三数之和 18.四数之和
数据结构的字典插入，哈希表使用
c_programj的博客
04-23 390
数据结构的字典插入，哈希表使用 hash基数（散列表，设计哈希函数，平均查找长度（分子为查找关键字的次数，分母为关键字的个数）） 散列表类似于数组结构，哈希函数可根据要求自己设置 #include using namespace std; #include<string.h> #include<stdio.h> typedef int KeyType; typedef in...
玩转数据结构从入门到进阶笔记（二 链表）
sinat_36748650的博客
04-16 590
链表Linked List： 上一篇中的动态数组，栈和两种队列底层依然依托于静态数组，其中动态是对于该数据结构的使用者来说的，依靠 resize方法解决动态扩容和缩容的问题。而链表是真正的动态数据结构，同时也是最简单的数据结构，是其他复杂数 据结构的基础。 它的数据储存在节点中，称之为Node，Node中储存了一个保存的数据和指向下一个节点的Node类型的引用next。下一 个节点没有数据则指向n...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值