基础数据结构——哈希表

目录

1.哈希表的概念

2.哈希表设计思想与原理

3.代码实现

---

1.哈希表的概念

   顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键 码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O( )，搜索的效率取决于搜索过程中 元素的比较次数。但显然这样子的效率还不足以满足我们在大数据的情况下的增删查改操作。

  那我们能否去实现一种增删查改均是O（1）的数据结构呢？于是哈希表便诞生了。

        构造一种存储结构，通过某种函 数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快 找到该元素。 

        当向该结构中：

        插入元素： 根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放

        搜索元素 ：对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功

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

2.哈希表的设计思想及原理 

假如我们要对数据集合{1，7，6，4，5，9}进行哈希，且哈希函数设置为hash(key) = key % capacity; capacity为存储元素底层空间总的大小。设此时capacity=10；

此时我们可以根据哈希函数得到下图的哈希表：

用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快。

但是假如我们此时再向集合中插入元素44 ，那么此时44%10=4，应该会插入在4这个位置，但是很明显这个位置上已经有元素存在了，所以这就引出了哈希冲突这个概念。

 2.1 哈希冲突

对于两个数据元素的关键字i和j，有：Hash(i) == Hash(j)，即：不同关键字通过相同哈 希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。

2.2 冲突避免 

 首先，我们需要明确一点，由于我们哈希表底层数组的容量往往是小于实际要存储的关键字的数量的，这就导致一 个问题，冲突的发生是必然的，但我们能做的应该是尽量的降低冲突率。

2.3 哈希函数的设计 

引起哈希冲突的一个原因可能是：哈希函数设计不够合理。 哈希函数设计原则：

1.哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1 之间

2.哈希函数计算出来的地址能均匀分布在整个空间中

3.哈希函数应该比较简单

常见哈希函数

1. 直接定制法--(常用)

取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B 优点：简单、均匀 缺点：需要事先知道关 键字的分布情况 使用场景：适合查找比较小且连续的情况。

2. 除留余数法--(常用)

设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数： Hash(key) = key% p(p<=m),将关键码转换成哈希地址

 3. 平方取中法--(了解）

4. 折叠法--(了解)

5. 随机数法--(了解)

6. 数学分析法--(了解)

由于哈希函数的设计不是我们的重点，jdk已经帮我们设计好了，所以我们这里仅做了解。

注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突

2.4 冲突避免——负载因子调节 

 负载因子和冲突率关系

当冲突率达到一个无法忍受的程度时，我们需要通过降低负载因子来变相的降低冲突率。

已知哈希表中已有的关键字个数是不可变的，那我们能调整的就只有哈希表中的数组的大小。 

2.5 冲突解决——开散列与闭散列 

闭散列：又叫开放寻址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以 把key存放到冲突位置中的“下一个” 空位置中去。

1.线性探测

比如上面的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，下标为4，因此44理论上应该插在该 位置，但是该位置已经放了值为4的元素，即发生哈希冲突。 线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。 

插入 ：

通过哈希函数获取待插入元素在哈希表中的位置 如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到 下一个空位置，插入新元素 

采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他 元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。 

2. 二次探测

其中二次探测的增量序列d为

  

研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不 会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情 况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容。

因此：比散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。 

开散列 ：又叫拉链法首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子 集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。相当于整个哈希表就是一个存储链表节点的数组，每个节点都是一个链表来存储冲突的值。类似于下图。

 

2.6 冲突严重时的解决方法 

当我们的子集合都比较大时我们的搜索效率实际上也会不佳，那么此时我们就可以将每个子集合转化为一棵红黑树（在jdk1.8时当链表长度>8且数组长度>64时子链表就会转化为红黑树）

3. 代码实现 

本次我们模拟jdk1.8采取开散列的方式来实现哈希表。且没有实现链表与红黑树的转化。

完整代码：https://gitee.com/invictusQAQ/hash-buck

初始化及构造方法：

static class Node{
        public int key;
        public int val;
        public Node next;

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

    public Node[] array;
    public int usedSize;

    public static final double DEFAULT_LOAD_FACTOR = 0.75;//负载因子阈值

    public HashBuck() {
        this.array = new Node[10];
    }

插入：

注意，每次插入要检查负载因子是否过大，如果过大要对哈希表进行扩容。扩容时要对原哈希表内的每个元素进行重新哈希。

public void put(int key,int val){
        //1、找到Key所在的位置
        int index=key%this.array.length;
        Node cur=array[index];
        //2、遍历这个下标的链表，看是不是有相同的key。有则更新val值
        while(cur!=null){
            if(cur.key==key){
                cur.val=val;
                return;
            }
            cur=cur.next;
        }

        Node node=new Node(key,val);
        //3.头插法
        node.next=array[index];
        array[index]=node;
        this.usedSize++;
        //4、插入元素成功之后，检查当前散列表的负载因子
        if(loadFactor() >= DEFAULT_LOAD_FACTOR) {
            resize();//
        }
    }

哈希表扩容：

private void resize(){
        Node[] newArray=new Node[array.length*2];
        for(int i=0;i<array.length;i++){
            Node cur=array[i];
            while(cur!=null){
                int index=cur.key%newArray.length;
                Node curNext=cur.next;//临时next节点
                cur.next=newArray[index];
                newArray[index]=cur;
                cur=curNext;
            }
        }
        array=newArray;//改变原数组引用
    }

 获取对应key值：

 

public int get(int key){
        //1、找到Key所在的位置
        int index = key % this.array.length;
        //2、遍历这个下标的链表
        Node cur = array[index];
        while(cur!=null){
            if(cur.key==key){
                return cur.val;
            }
            cur=cur.next;
        }
        return -1;//不存在
    }

最后简单提一下哈希表的一些注意事项 ：

1.哈希表在创建时是没有分配内存的，此时长度为零。只有当插入第一个元素时才会分配内存

2.哈希表的长度一定是2的次幂（如果你初始化大小不为2的次幂则哈希表大小为和你初始化值最近的2的次幂）