哈希表的介绍 ( Java实现 )

一.哈希表的概念

顺序结构以及平衡树中,元素的key与存储位置之间没有对应的关系,因此在查找一个元素时,必须经过key的多次比较,直到找到为止. 顺序查找时间复杂度为O(N),平衡树中为树的高度即O(log2N),搜索的效率取决于搜索过程中比较的次数.

理想的搜索方法: 可以不经过任何比较,一次直接从表中得到想要的元素. 如果构造一种数据结构,通过某种函数(hashFunc)使元素的存储位置与其key能够建立一一映射的关系,那么在查找时通过该函数可以很快找到该元素.

当向该结构中:

• 插入元素

  根据待插入的key,以此函数算出该元素的存储位置并按该位置存放

• 搜索元素

  对元素的key进行同样的运算,把求得的值当作存储为止,取出该位置的元素,然后比较key知否相等,若相等,则成功

该方式即为哈希(散列)方法,哈希方法中使用的转换函数称为哈希(散列)函数,构造出来的结构称为哈希表(HashTable)(或者散列表)

例如 : 数据集合 {1，7，6，4，5，9};

哈希函数设置为:hash(key) = key % capacity; capacity为存储元素底层空间的大小

用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快, 但按照上面的哈希方式,插入元素的key是44会有什么问题?

二.哈希冲突

1.冲突-概念

对于两个数据元素的关键字ki和kj(i != j), 有ki != kj, 但有 Hash(ki) == Hash(kj), 即: 不同的关键字通过相同的哈希函数计算出相同的哈希地址,该现象成为哈希冲突或者哈希碰撞

把具有不同关键码而具有相同哈希地址的数据元素称为“同义词"

2.冲突-避免

我们需要明确一点,我们哈希表中数组的存储容量往往是要小于实际要存储的关键字的数量,这就导致一个问题,冲突是必然的,但我们能做的是尽量降低冲突率

3.哈希函数书设计

引起哈希冲突一个很重要的原因是: 哈希函数设计的不合理.

哈希函数设计原则:

• 哈希函数的定义域必须包括需要存储的全部关键码,确保任何关键码作为输入传给哈希函数都不会发生映射失败的情况;如果哈希表允许有m个地址时,其值域必须在 0 到 m - 1之间
• 哈希函数计算出来的地址能够均匀的分布
• 哈希函数应该比较简单

4.负载因子调节

负载因子和冲突率的关系粗略演示:

冲突率高到一定值时,我们就需要通过降低负载因子来降低冲突率

哈希表中已有的关键字的个数是不可变的,我们能改变的只有哈希表数组的大小

三.冲突解决(开散列和闭散列)

1.开散列

开散列:也叫开放地址法,当发生哈希冲突时,如果哈希表为被填满,那就说明一定还有空着的地址,那么就可以把key存储到冲突位置的"下一个"位置中去

如何找寻下一个空位置:

1. 线性探测

   • 从发生冲突的位置开始, 依次向后探测, 直到寻到下一个空位置为止

   • 像上面的例子, 如果插入的key是44的话, 那么计算出的哈希地址是4,然而已经有4在其位置了, 只能向后找空位置, 发现index为8的位置是空的, 那么就插入到8的位置

   

   • 采用闭散列解决哈希冲突时, 不能随便物理的删除哈希表中已有的元素, 若直接删除元素会影响其他元素的查询. 像上表中如果删除4 那么查询44是否存在时,发现其对应的哈希地址为4,但已经删除了其原有的key,其位置为空却并不代表没有44,其真正在在index为8的位置上.因此线性探测采用标记的伪删除法来删除一个元素

2. 二次探测

   • 二次探测与线性探测类似, 当发生哈希冲突时,线性探测是寻找下一个空位置, 而二次探测是使用二次探测序列来查找下一个可用的槽位.
   • 探测序列通常是一个二次方程, 例如: H = (H₀ + i²) % m 或者 H = (H₀ - i²) % m ,其中 i = 1, 2, 3…, H是通过哈希函数对key进行计算得到的位置, m表示表的大小
   • 二次探测的性能取决于装填因子的大小和探测序列的选择. 当装填因子较小时, 二次探测可能比线性探测更快快, 但当装填因子接近1时, 可能会导致性能下降和聚集问题

开放地址散列都需要动态的对表的大小进行调整, 控制负载因子避免过高来提升效率

2.闭散列

在封闭地址散列中, 哈希表的每个位置通常是一个桶(bucket), 用来储存多个元素, 而不是单单一个元素, 当发生哈希冲突时,冲突的元素将被添加到同一槽位的桶中, 通常使用链表, 数组, 或其他数据结构来组织这些元素

哈希桶的代码实现 :

// key-value 模型
public class HashBucket {
    private static class Node {
        private int key;
        private int value;
        Node next;

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


    private Node[] array;
    private int size;   // 当前的数据个数
    private static final double LOAD_FACTOR = 0.75;
    private static final int DEFAULT_SIZE = 10;//默认桶的大小

    public HashBucket() {
        this.array = new Node[DEFAULT_SIZE];
    }

    public int put(int key, int value) {
        // write code here
        int index = key % array.length;
        Node cur = array[index];
        Node node = new Node(key, value);
        if (cur == null) {
            array[index] = node;
        } else {
            while (cur.next != null) {
                if (cur.key == key) {
                    int oldValue = cur.value;
                    cur.value = value;
                    return oldValue;
                }
                cur = cur.next;
            }
            if (cur.key == key) {
                int oldValue = cur.value;
                cur.value = value;
                return oldValue;
            }
            cur.next = node;
        }
        size++;
        if (loadFactor() >= LOAD_FACTOR) {
            resize();
        }
        return -1;
    }

    //前插
    public void put1(int key, int value) {
        int index = key % array.length;

        Node cur = array[index];
        //先遍历一遍整体的链表 是否存在当前key
        while (cur != null) {
            if (cur.key == key) {
                cur.value = value;
                return;
            }
            cur = cur.next;
        }
        //没有这个key
        Node node = new Node(key, value);
        node.next = array[index];
        array[index] = node;
        size++;

        if (loadFactor() >= 0.75) {
            resize();
        }
    }

    private void resize() {
        // write code here
        Node[] newArray = new Node[array.length * 2];
        //遍历原来的数组   将所有的元素  “重新哈希” 到新数组中！
        for (int i = 0; i < array.length; i++) {

            Node cur = array[i];
            while (cur != null) {
                //尾插
                int newIndex = cur.key % newArray.length;
                Node tmp = newArray[newIndex];
                Node node = new Node(cur.key, cur.value);
                if (tmp == null) {
                    newArray[newIndex] = node;
                } else {
                    while (tmp.next != null) {
                        tmp = tmp.next;
                    }
                    tmp.next = node;
                }
                cur = cur.next;
            }
        }
        //再将新数组赋给原数组
        array = newArray;
    }

    //前插
    private void resize1() {
        Node[] tmpArr = new Node[array.length * 2];
        //遍历原来的数组 将所有的元素    《重新哈希》到新的数组当中
        for (int i = 0; i < array.length; i++) {
            Node cur = array[i];
            while (cur != null) {
                //记录当前节点的下个节点
                Node curNext = cur.next;
                int newIndex = cur.key % tmpArr.length;
                //头插
                cur.next = tmpArr[newIndex];
                tmpArr[newIndex] = cur;
                cur = curNext;
            }
        }
        array = tmpArr;
    }

    private double loadFactor() {
        return size * 1.0 / array.length;
    }

    public int get(int key) {
        // write code here
        int index = key % array.length;
        Node cur = array[index];
        while (cur != null) {
            if (cur.key == key) {
                return cur.value;
            }
            cur = cur.next;
        }
        return -1;
    }
}