『数据结构与算法』散列表（哈希表）

时间  2021-02-16
标签 java node git github 算法 数组 微信 网络 数据结构 函数 栏目 Java 繁體版
原文   原文链接

微信搜索：码农StayUp
主页地址：https://gozhuyinglong.github.io
源码分享：https://github.com/gozhuyinglong/blog-demosjava

1. 什么是散列表

散列表（Hash Table）也叫哈希表，是根据给定关键字（Key）来计算出该关键字在表中存储地址的数据结构。也就是说，散列表创建了关键字与存储地址之间的一种直接映射关系，将关键字映射到表中记录的地址，这加快了查找速度。node

使用函数表达式来表示，应为：hash(key)=v，其中key为关键字，hash()为散列函数，v为散列地址。git

1.1 相关术语

  • 关键字（Key）：关键字是散列表的查找对象，也是散列函数的参数。其能够是记录自己，也能够是记录的惟一索引，这取决于散列表的设计。
  • 散列函数（Hash Function）：将关键字映射为散列表中适当存储地址的函数称为散列函数，也叫作哈希函数。
  • 散列地址（Hash Address）：将关键字经过散列函数计算出的地址称为散列地址，也叫作散列值、哈希值。
  • 散列表（Hash Table）：这种使用散列技术来存储数据记录的表称为散列表。
  • 散列冲突（Hash Collision）：当不一样的关键字具备相同的散列地址，这种现象称为冲突，也叫作哈希冲突。而这些关键字对该散列函数来讲是同义词。
  • 表长：散列表的大小，即可以存储散列地址的数量。用m表示。

1.2 举个例子

一个比较通俗的例子，就是咱们手机中的通信录。通信录用于存储联系人的姓名及电话号码信息，它是一个按照姓名首字母进行顺序排列的表。好比咱们找“嬴政”就能够经过字母“Y”进行快速定位，并找到“嬴政”。github

散列表：通信录

  • 在该例子中，姓名“嬴政”即是关键字。
  • 取姓名的首字母的算法即是散列函数。即：hash(嬴政) = Y。
  • 经过
  • 当咱们定位到“Y”地址后，不只有“赢政”，还有“赢异人”，也就是说，经过关键字“赢异人”也能找到“Y”的地址，这种现象即是冲突。即：hash(嬴政) = hash(嬴异人) = Y。
  • 而“赢政”与“赢异人”对该散列函数来讲是同义词。
  • 这个用于存储联系人的通信录即是散列表。

1.3 小结

本章节介绍了散列表的概念及相关术语，并以一个通信录的例子来加深对散列表的了解。但还有一些问题等待咱们解决，那就是“散列冲突”。咱们一方面能够经过精心设计散列函数来尽可能减小冲突的次数，另外一方面仍须要提供解决冲突的方法。后面章节会详细介绍散列函数的设计和解决冲突的方法。算法

2. 散列函数的设计

散列函数的设计原则应该遵循计算简单、散列地址分布均匀。下面咱们介绍几种经常使用的散列函数的构造方法。数组

2.1 直接定址法

取关键字或关键字的某个线性函数值为散列地址。即hash(key) = key 或 hash(key) = a * key + b，其中a、b 为常数。这种散列函数也叫作自身函数。微信

以下图中，咱们要获取某个岗位级别的信息，就可使用级别减去1来做为地址，即：hash(key) = key - 1网络

直接定址法

直接定址法的优势是简单、均匀也不会产生冲突。但因为这是一种拿空间换时间的方式，因此适合查找表较小且连续的状况。好比年龄、岗位级别等。数据结构

2.2 数字分析法

经过分析一组数据，这些数据中可能出现的关键字都是事先知道的，则能够取关键字的若干数位组成散列地址。取出的这部分数据要在其数位上出现的频率小，这样出现冲突的概率就会很小。函数

好比手机号码，其前3位为网络识别号，中间4位为地区编码，然后4位才是真正的用户号码。那么在某个公司中，其员工的手机号码前7位出现冲突的几率会很大，然后4位出现冲突的几率会很小，则能够取后四位作为散列地址。

数字分析法

2.3 平方取中法

取关键字平方后的中间几位做为散列地址。该方法是一个产生伪随机数的方法，由冯·诺伊曼在1946年提出。

平方取中法

2.4 折叠法

将关键字分割成位数相同的几部分（最后一部分的位数能够不一样），而后取这几部分的叠加和（舍去进位）做为散列地址。这种方法比较适用于关键字位数不少的状况。

好比关键字为 1234567890，散列表的表长为3位：
（1）将关键字分为4组： 123|456|789|0
（2）将它们叠加求和：123 + 456 + 789 + 0 = 1368
（3）舍去进位，得：368 ，即为最终散列地址

2.5 除留余数法

假定散列表的表长为m，取一个不大于m但最接近或等于m的质数p，经过关键字对p取模运算来转换为散列地址。散列函数为：hash(key) = key % p，其中p $\leq$ m。

不只能够对关键字直接取模，也能够在折叠法、平方取中法等运算后取模。对p的选择很重要，若选择很差很容易产生冲突。

除留余数法

3. 散列冲突的处理方法

解决冲突的方法有几种，这里咱们将讨论其中最简单的两种：开放定址法和链地址法（拉链法）。

3.1 开放定址法

将产生冲突的散列地址作为自变量，经过某种冲突解决函数获得一个新的空闲散列地址。即当产生冲突后，寻找下一个空闲的散列地址。根据寻找的方式不一样又分为几种方法，下面来介绍。

3.1.1 线性探测法

当产生冲突时， 顺序探测表中下一地址，直探测到一个空闲（自由）的地址，将记录插入。若一直探测到表尾地址m-1,则下一探测地址为表首地址0。当表满的时候，则探测失败。

好比下图散列表的散列函数使用除留余数法（m=10, p=10）。那么咱们顺序插入十二、1三、24时顺利插入到对应地址中，再插入3四、44时会产生冲突，使用线性探测法，继续探测下一地址，将插入到空闲地址上。

线性探测法

线性探测法会形成大量元素在相邻的散列地址上“汇集”起来，使得咱们要不断处理冲突，这大大下降查找和存入效率。

3.1.2 平方探测法

平方探测法是消除线性探测法中的汇集问题的一种冲突解决方法。设发生冲突的地址为d，那么使用平方探测法获得的新的地址序列为d $\pm$ 1^二、d $\pm$ $2^2$、d $\pm$ $3^2$...d $\pm$ $key^2$（key $\leq$ m/2）。

仍是刚才那个例子，当插入34时，在下标为4的位置产生冲突，咱们先计算一下在该位置探测的序列： 4 + $1^2$ = 五、4 - $1^2$ = 三、4 + $2^2$ = 八、4 - $2^2$ = 0，即：五、二、八、0，因此34应该被放到5的位置。而44应该放到8的位置。

平方探测法

平方探测法的缺点是不能探测到散列表上全部的地址，但至少能探测到一半地址。

3.1.3 伪随机探测法

伪随机探测法是当发生地址冲突时，地址增量为伪随机数序列。

伪随机数是说，若是咱们设置随机种子相同，则不断调用随机函数能够生成不会重复的数列，咱们在查找时，用一样的随机种子，它每次获得的数列是相同的，相同的地址固然能够获得相同的散列地址。

3.1.4 双散列

双散列顾名思义是使用了两个散列函数，当执行第一个散列函数获得的地址发生冲突时，则执行第二个散列函数来计算该关键字的地址增量。

一种常见的算法是：(hash1(key) + i * hash2(key)) mod m，其中i为冲突次数，hash1()为第一个散列函数，hash2()为第二个散列函数，m为散列表大小。当发生冲突后，咱们经过重复增长步长i来寻址。

仍是以上面的例子为例。第一个散列函数为hash1(key) = key mod 10，第二个散列函数设为hash2(key) = key mod 3。

经过上面公式，能够计算出关键字34的散列地址： (34 mod 10 + 1 * (34 mod 3)) mod 10 = (4 + 1 * 1) mod 10 = 5。而关键字44的散列地址为：(44 mod 10 + 2 * (44 mod 3)) mod 10 = (4 + 2 * 2) mod 10 = 8

双散列

3.2 链地址法

链地址法又称拉链法，是利用链表来解决冲突的一种方法，即把具备相同散列地址的关键字记录存入到同一个单链表中，该链表称为同义词链表。每个散列地址都有一个对应的链表。

仍是上面的例子，使用链地址法的存储模型以下图所示。

链地址法

4. 代码实现

咱们使用链地址法来实现上例中散列表，其散列函数使用除留余数法。

4.1 节点类

由于链表不是本篇重点，因此这里设计一个简单的节点类。关于链表的相关知识请参阅：《 链表（单链表、双链表、环形链表） 》

class Node {
    private final int key; // 关键字
    private Node next; // 下一节点

    public Node(int key) {
        this.key = key;
    }

    public int getKey() {
        return key;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}

4.2 散列表类

散列表类使用数组存储表数据，其指向链表的头节点，其散列函数使用除留余数法。

本类主要实现了散列表的添加关键字、删除关键字和匹配关键字。

class HashTable {

    private final int size; // 散列表大小
    private final Node[] table; // 散列表

    private HashTable(int size) {
        this.size = size;
        this.table = new Node[size];
    }

    /**
         * 散列函数 - 除留余数法
         *
         * @param key
         * @return
         */
    private int hash(int key) {
        return key % size;
    }

    /**
         * 添加关键字
         *
         * @param key
         */
    public void add(int key) {
        int hashAddress = hash(key);
        if (table[hashAddress] == null) {
            table[hashAddress] = new Node(key);
            return;
        }
        add(table[hashAddress], key);
    }

    /**
         * 添加关键字 - 递归
         *
         * @param node
         * @param key
         */
    private void add(Node node, int key) {
        if (node.getNext() == null) {
            node.setNext(new Node(key));
            return;
        }
        add(node.getNext(), key);
    }

    /**
         * 匹配关键字
         *
         * @param key
         * @return
         */
    public boolean contains(int key) {
        int hashAddress = hash(key);
        Node headNode = table[hashAddress];
        if (headNode == null) {
            return false;
        }

        return contains(headNode, key);
    }

    /**
         * 匹配关键字 - 递归
         *
         * @param node
         * @param key
         * @return
         */
    private boolean contains(Node node, int key) {
        if (node == null) {
            return false;
        }
        if (node.getKey() == key) {
            return true;
        }
        return contains(node.getNext(), key);
    }

    /**
         * 移除关键字
         *
         * @param key
         */
    public void remove(int key) {
        int hashAddress = hash(key);
        Node headNode = table[hashAddress];
        if (headNode == null) {
            return;
        }
        if (headNode.getKey() == key) {
            table[hashAddress] = headNode.getNext();
            return;
        }
        remove(headNode, key);
    }

    /**
         * 移除关键字 - 递归
         *
         * @param node
         * @param key
         */
    private void remove(Node node, int key) {
        if (node.getNext() == null) {
            return;
        }
        if (node.getNext().getKey() == key) {
            node.setNext(node.getNext().getNext());
            return;
        }
        remove(node.getNext(), key);
    }

}

5. 完整代码

完整代码请访问个人Github，若对你有帮助，欢迎给个Star，谢谢！

https://github.com/gozhuyinglong/blog-demos/blob/main/java-data-structures/src/main/java/io/github/gozhuyinglong/datastructures/hashtable/HashTableDemo.java

推荐阅读

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程