带你彻底搞懂哈希表的前世今生

fastsy

已于 2022-11-03 12:31:09 修改

阅读量921

点赞数 2

分类专栏：数据结构与算法文章标签：数据结构算法

于 2020-05-26 20:33:37 首次发布

本文链接：https://blog.csdn.net/RunningXiaoHei/article/details/106364338

版权

数据结构与算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

哈希表

哈希表是一种数据结构，基于数组，它可以提供快速的插入操作和查找操作。在认识哈希表之前，我们先来看一个场景：

将一个公司的100名员工信息存储起来，每个员工都有编号，从0~99,这里，员工编号是连续、有序且不会重复的。在这种情况下，我们很自然地会想到用数组来存储，把编号作为数组下标，然后将员工信息压入数组中,这样查找员工就很方便很快速了。

/**
 * 员工信息类
 */
public class Customer {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Client {
    public static void main(String[] args) {
        Customer[] customers = new Customer[100];
        for (int i = 0; i < 100; i++){
            Customer customer = new Customer();
            customer.setId(i);
            customer.setName("员工"+i);
            customers[customer.getId()] = customer;
        }
    }
}

那如果我们换个前提条件:员工编号不是连续的，如：1、11、20、55、143…,这样还能用员工编号作为数组下标吗？这里显然不合理。可能你会说可以直接这样存：

        Customer[] customers = new Customer[1000];
        for (int i = 0; i < 1000; i++){
            Customer customer = new Customer();
            customer.setId(i);
            customer.setName("员工"+i);
            customers[i] = customer;
        }

但我们知道，数组是添加、删除简单，但查找复杂，所以这时不适合用循环遍历的方式存入。
针对上面的情形，我们知道单纯的数组存储不适合，那我们能不能想个办法依旧是将员工编号作为索引存入数组呢？

哈希函数

我们知道，不能直接将员工编号作为数组下标存入数组的原因是员工编号太过于分散，且编号大小会大于数组大小，这样的话不能一一映射到数组中去。所以我们首先要解决的问题是需要将这些大于数组大小且分散的数据通过某种运算转换为在数组大小范围内的数据。
假如给定一个数据112，而数组大小为100，我们会把它存到数组的哪个位置呢？很简单，我们可以通过112%100=12 来得到其下标值，这样算出来的值肯定在100以内，这个算法其实就是一种哈希算法，它可以将一个数据的大小哈希化为某个范围内。

因此，针对上面的场景，我们可以将员工编号与数组大小取余来得到其下标，然后将其存入数组中。
到这里，是不是就结束了，大家有没有发现什么问题？上面数组大小为1000，如果有这样几个编号的员工：11、111、211，我们通过上面的算法得到其下标依次为：11%100=11，111%100=11，211&100=11。这里就有问题了，这三个员工编号通过转化后的下标都一样，这要怎么存呢？
这里，我们就要引入另一个概念了：哈希冲突。

##哈希冲突
上面我们提到了通过哈希函数得到员工在数组中的下标一样，这时候就出现了冲突，我们不能将不同的员工存入数组的同一单元，如何解决这个冲突呢？
这里提供两种方式：开放地址法 和 链地址法

开放地址法

在开放地址法中，若数据不能直接放在由哈希函数计算出来的数组下标所指的单元时，就要寻找数组中的其他位置，下面要探索开放地址法中的三种方法，它们在找下一个空白单元时使用的方法不同。这三种方法分别是线性探测、二次探测和再哈希法。

线性探测

在线性探测中，线性地查找空白单元。如果1是要插入数据的位置，它已经被占用了，那么就使用2，然后3，依次类推，直到找到空位。这就叫线性探测，它沿着数组的下标一步一步顺序地查找空白单元。
基于上面员工信息存储的案例，我们用代码来体现线性探测：

/**
 * 员工信息类
 */
public class Customer {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "{姓名:"+name+" 编号:"+id+"}";
    }
}

public class HashTable {
    private Customer[] customers;
    private int _size;


    public HashTable(int size){
        //存储员工数组
        this.customers = new Customer[size];
        //数组大小
        this._size = size;
    }

    /**
     * 存入员工信息
     * @param customer
     */
    public void put(Customer customer){
        int id = customer.getId();
        //得到员工在数组中的下标
        int hasValue = hashValue(id);
        //线性探测指定的员工
        while(customers[hasValue] != null){
            //如果哈希函数得到的下标所在单元已经有了元素，那么就往后查找存入的位置
            ++hasValue;
        }
        if (hasValue < _size){
            customers[hasValue] = customer;
        }else{
            throw new StackOverflowError("数组越界");
        }
    }

    /**
     * 通过id查找员工
     * @param id
     * @return
     */
    public Customer find(int id){
        //哈希函数得到员工下标
        int hasValue = hashValue(id);
        //如果对应下标没有元素或者其元素的id与要查找id不一致，则继续往后探测
        while (customers[hasValue] == null || customers[hasValue].getId() != id){
            ++hasValue;
        }
        if (hasValue < _size){
            return customers[hasValue];
        }else{
            throw new StackOverflowError("数组越界");
        }
    }

    /**
     * 哈希函数获取真实下标
     * @param key 员工编号
     * @return
     */
    public int hashValue(int key){
        while(key > _size){
            key %= _size;
        }
        return key;
    }

    public void show(){
        for (Customer customer : customers){
            if (customer == null){
                customer = new Customer();
                customer.setName("");
                customer.setId(-1);
            }
            System.out.print(customer.toString());
        }
    }
}

现在，假设两个员工的编号分别为201、301，通过hasValue()得到真实下标都为1，然后通过线性探测法，因为201会首先放到下标1的位置，因此301会往后探测到下标为2的位置，这个位置此时肯定是空，所以就吧301放到下标为2的位子，探测结束。用代码来验证下：

 public static void main(String[] args) {
        HashTable hashTable = new HashTable(100);
        Customer customer01 = new Customer();
        customer01.setId(201);
        customer01.setName("员工:201");

        Customer customer02 = new Customer();
        customer02.setId(301);
        customer02.setName("员工:301");
        
        hashTable.put(customer01);
        hashTable.put(customer02);
        hashTable.show();
    }

得到的结果截图如下：
在这里插入图片描述
可以看到与我们上面说的结果一致。

二次探测

线性探测法固然解决了冲突问题，但是，随着哈希表中的数据越来越多，这些数据越来越聚集，会使得探测长度也越来越长，这也就意味着序列最后的单元会非常耗时。
已填入哈希表的数据项和表长的比率称为装填因子(loadFactor),有100个单元的哈希表填入了50个数据后，它的填装因子就是1/2。当装填因子不太大时，聚集分布的比较连贯，哈希表的某个部分可能包含大量的聚集，而另一部分还很稀疏。聚集降低了哈希表的性能。

二次探测是降低聚集发生的一种尝试，思路是探测相隔较远的单元，而不是和原始位置相邻的单元。

在线性探测中，如果哈希函数计算的原始下标是x，线性探测就是x+1、x+2、x+3…x+n;而在二次探测中，探测的过程是x+1、x+4、x+9…x+n^2。

二次探测的问题

二次探测消除了在线性探测中出现的聚集问题，这种聚集成为原始聚集。然而，二次探测也产生了另一种，更细的聚集问题。之所以会发生，是因为所有映射到同一位置的关键字在寻找空位时，探测的单元都是一样的。

比如101、201、301依次插入到表中，它们都映射到1，那么101需要以1为步长的探测，201需要以4为步长的探测，301需要以9为步长的探测。因此，越是往后插入且映射为1的数据在寻找空位时所需的探测不长越长，且它们走过的路径也一样，都是1、4、9…n^2。这个现象叫做二次聚集。

二次聚集不是一个严重的问题，但是，二次探测不会经常使用，再哈希法是更好的选择。

再哈希法

再哈希法就是把关键字用不同的哈希函数再做一遍哈希化，用这个结果作为步长。这个哈希函数应该具备以下特点：

和第一个哈希函数不同
不能输出0

这里直接给出这个函数：
stepSize = constant - key % constant
其中，constant是质数，且小于数组容量。
现在我们用再再哈希法替代线性探测法来改写上面的代码：

  /**
     * 再哈希法存入员工信息
     * @param customer
     */
    public void put2(Customer customer){
        int id = customer.getId();
        //得到员工在数组中的下标
        int hasValue = hashValue(id);
        int stepSize = hashValue2(id);
        //线性探测指定的员工
        while(customers[hasValue] != null){
            hasValue += stepSize;
        }
        if (hasValue < _size){
            customers[hasValue] = customer;
        }else{
            throw new StackOverflowError("数组越界");
        }
    }
    
     /**
     * 再哈希法 通过id查找员工
     * @param id
     * @return
     */
    public Customer find2(int id){
        //哈希函数得到员工下标
        int hasValue = hashValue(id);
        int stepSize = hashValue2(id);
        //如果对应下标没有元素或者其元素的id与要查找id不一致，则继续往后探测
        while (customers[hasValue] == null || customers[hasValue].getId() != id){
            hasValue += stepSize;
        }
        if (hasValue < _size){
            return customers[hasValue];
        }else{
            throw new StackOverflowError("数组越界");
        }
    }
    
     /**
     * 再哈希法得到步长
     * @param key
     * @return
     */
    public int hashValue2(int key){
        return 5 -  key%5;
    }

可以看到，再哈希法相教于线性探测法的区别在于寻找空位时，前者的步长会通过二次哈希函数得到，因此每次进入哈希表的元素得到的步长都不等，这就防止了聚集的问题。

链地址法

开放地址法中，通过在哈希表中再寻找一个空位解决冲突问题。另一个方法是在哈希表每个单元中设置链表。某个数据项的关键字值还是像通常一样映射到哈希表的单元，而数据项本身插入到这个单元的链表中，其他同样映射到这个位置的数据项只需要加到链表中：不需要在原始的数组中寻找空位。入下图所示：
在这里插入图片描述

还是上面的例子，我们用代码实现：

/**
 * 链节点
 */
public class Link {
    Customer customer;
    Link next;

    public Link(Customer customer){
        this.customer = customer;
    }

    public void displayLink(){
        System.out.print(customer.toString());
    }
}

/**
 * 装载Customer的链表
 */
public class LinkList {
    Link first;

    public void insert(Customer customer){
        Link newLink = new Link(customer);
        if (first == null){
            first = newLink;
        }else{
            Link current = first;
            Link parent = null;
            while(current != null){
                parent = current;
                current = current.next;
            }
            parent.next = newLink;
        }
    }

    public Customer find(int key){
        if (first == null){
            throw new NullPointerException("链表为空");
        }else{
            Link current = first;
            while(current != null && key != current.customer.getId()){
                current = current.next;
            }
            if (current == null){
                return null;
            }else{
                return current.customer;
            }
        }
    }

    public void display(){
        Link current = first;
        while(current != null){
            current.displayLink();
            current = current.next;
        }
    }
}

/**
 * 链地址法的哈希表
 */
public class HashTable {
    private LinkList[] linkLists;
    private int _size;


    public HashTable(int size){
        //存储员工数组
        this.linkLists = new LinkList[size];
        //数组大小
        this._size = size;

        for (int i = 0; i < size; i++){
            linkLists[i] = new LinkList();
        }
    }

    public void put(Customer customer){
        int id = customer.getId();
        //得到员工在数组中的下标
        int hasValue = hashValue(id);
        LinkList linkList = linkLists[hasValue];
        linkList.insert(customer);
    }

    public Customer find(int id){
        //得到员工在数组中的下标
        int hasValue = hashValue(id);
        LinkList linkList = linkLists[hasValue];
        return linkList.find(id);
    }

    /**
     * 哈希函数获取真实下标
     * @param key 员工编号
     * @return
     */
    public int hashValue(int key){
        while(key > _size){
            key %= _size;
        }
        return key;
    }

    public void show(){
        for (LinkList linkList : linkLists){
            linkList.display();
        }
    }
}

还是将编号为201、301的员工存入哈希表，采用链地址法寻找元素的单元时，201对应链表数组的下标为1,因此首先会将其放到linkLists[1]的链表头部，此时，因为301对应的链表数组下标也为1，所以它也会被放到linkLists[1]的链表中，但因为头部已经放入了201,所以它会向链表的下个节点寻找位置，知道找到空位，就会将其存入。
用代码来验证下：

 public static void main(String[] args) {
        HashTable hashTable = new HashTable(100);
        Customer customer01 = new Customer();
        customer01.setId(201);
        customer01.setName("员工:201");

        Customer customer02 = new Customer();
        customer02.setId(301);
        customer02.setName("员工:301");

        hashTable.put(customer01);
        hashTable.put(customer02);
        hashTable.show();
    }

输出结果如下：
在这里插入图片描述

总结

哈希表基于数组
关键字值的范围通常比数组容量大
关键字值通过还函数映射为数组的下标
一个关键字哈希化到已占用的数组单元，这种情况叫冲突
冲突的解决方法：开放地址法和链地址法
开放地址法有三种：线性探测、二次探测和再哈希法
链地址法中，每个数组单元包含一个链表。把所有映射到同一数组下标的数据项都查到这个链表中。
在线性探测中，已填充的单元的长度不断增加，它们叫做首次聚集，聚集会降低哈希表的效率。
在二次探测中，x的位移是步数的平方，所以探测序列就是x+1、x+4、x+9…依次类推
二次探测消除了首次聚集，但是产生了二次聚集，它比首次聚集的危害略小。
二次聚集的发生是因为所有映射到同一单元的关键字，在探测过程中执行了相同的序列。因为步长只依赖于哈希值，与关键字无关
再哈希法中，如果第二个哈希函数返回一个值s，那么探测序列就是x、x+2s、x+3s，依次类推，这里的s由关键字得到，但探测过程中保持常量
装填因子是表中数据项和数组容量的比值
开放地址法中的最大装填因子应该在0.5附近，若具有相同的装填因子，对于再哈希法来说，查找的平均探测长度是2
在开放地址法中，当装填因子接近于1时，查找时间趋于无限
对于链地址法，装填因子为1比较合适

fastsy

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
带你彻底搞懂哈希表的前世今生

哈希表哈希表是一种数据结构，基于数组，它可以提供快速的插入操作和查找操作。在认识哈希表之前，我们先来看一个场景：将一个公司的100名员工信息存储起来，每个员工都有编号，从0~99,这里，员工编号是连续、有序且不会重复的。在这种情况下，我们很自然地会想到用数组来存储，把编号作为数组下标，然后将员工信息压入数组中,这样查找员工就很方便很快速了。/** * 员工信息类 */public class Customer { private int id; private String na
复制链接

扫一扫