数据结构基础知识【十一】：哈希表

哈希表

一 . 概念

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。
例如：

二 . 冲突

1.概念

不同关键字通过相同哈希函数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。
例如：

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

2.哈希冲突

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

1. 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间。即必须在表格的范围之内。
2. 哈希函数计算出来的地址能均匀分布在整个空间中。
3. 哈希函数应该比较简单。

一个哈希函数不论设计的有多精妙，都不能绝对解决哈希冲突，但是其可以将发生哈希冲突的概率降低。

3.常见哈希函数

4. 直接定制法：取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B 优点：简单、均匀 缺点：需要事先知道关键字的分布情况 使用场景：适合查找比较小且连续的情况。
5. 除留余数法：设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址。
6. 平方取中法：假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址;再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址 平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况。
7. 折叠法：折叠法是将关键字从左到右分割成位数相等的几部分(最后-部分位数可以短些)， 然后将这几部分叠加求和,并按散列表表长，取后几位作为散列地址。折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况。
8. 随机数法：选择一个随机函数,取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。通常应用于关键字长度不等时采用此法。
9. 数字分析法：数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况。

4.负载因子

哈希负载因子α=填入哈希表中的有效元素个数 / 哈希表的长度（容量）
a是散列表装满程度的标志因子。由于表长是定值，a与“填入表中的元素个数”成正比，所以，a越大，表明填入表中的元素越多，产生冲突的可能性就越大;反之，a越小，标明填入表中的元素越少，产生冲突的可能性就越小。实际上，散列表的平均查找长度是载荷因子a的函数，只是不同处理冲突的方法有不同的函数。
负载因子和冲突率的关系粗略演示

所以当冲突率达到一个无法忍受的程度时,我们需要通过降低负载因子来变相的降低冲突率。
已知哈希表中已有的关键字个数是不可变的，那我们能调整的就只有哈希表中的数组的大小。

5.解决哈希冲突

1. 闭散列
   闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。
   寻找“下一个”位置的方法：
   （1）线性探测：
   从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
   插入：通过哈希函数获取待插入元素在哈希表中的位置；如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素。
   删除：采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。
   优点：找下一个地址的方式简单。
   缺点：容易产生数据堆积，发生哈希冲突的元素容易连成一片。
   （2）二次探测：
   线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为：H(i) = (H(0) +i^2 )% m, 或者：H(i) = (H(0) -i^2)% m。其中：i = 1,2,3…， H(0)是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小。
   优点：解决了线性探测容易产生数据堆积的问题。
   缺点：如果空位置较少，可能需要多次探测。
2. 开散列
   开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。哈希表中没有直接存元素。

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

三 . 代码实现

public class HashBucket {
    public static class Node{
        int key;
        int value;
        Node next;
        Node(int key,int value){
            this.key = key;
            this.value = value;
            next = null;
        }
    }
    //哈希桶中的成员数据
    Node[] table;
    int capacity; //桶的个数
    int size;  //有效元素的个数
    double loadFact = 0.75;
    public HashBucket(int initCap){
        //保证哈希桶初始的容量至少为10个
        capacity = initCap;
        if (initCap < 10){
            capacity = 10;
        }
        table = new Node[capacity];
        size = 0;
    }
    //插入
    public int put(int key,int value){
        //1.通过哈希函数，计算key所在的桶号
        int bucketNo = hashFunc(key);
        //2.在bucketNo桶中检测key是否存在
        //检测方式：遍历链表
        Node cur = table[bucketNo];
        while (null != cur){
            if (cur.key == key){
                int oldValue = cur.value;
                cur.value = value;
                return oldValue;
            }
            cur = cur.next;
        }
        //3.key不存在，将key-value插入到哈希桶中
        cur = new Node(key,value);
        cur.next = table[bucketNo];
        table[bucketNo] = cur;
        size++;
        return value;
    }
    //删除
    //将哈希桶中为key的键值对删除
    public boolean remove(int key){
        //1.通过哈希函数计算key的桶号
        int bucketNo = hashFunc(key);
        //2.在bucketNo桶中找key所对应的节点
        //找到后该节点删除
        Node cur = table[bucketNo];
        Node prev = null;
        while (null != cur){
            if (cur.key == key){
                //找到key所对应的节点,将该节点删除
                //删除其他节点
                if (null == prev){
                    //删除的节点刚好是第一个节点
                    table[bucketNo] = cur.next;
                }else {
                    prev.next = cur.next;
                }
                --size;
                return true;
            }else {
                prev = cur;
                cur = cur.next;
            }
        }
        return false;
    }

    public boolean containsKey(int key){
        //1.计算key所在的桶号
        int bucketNo = hashFunc(key);
        //2.在bucketNo桶中找key
        Node cur = table[bucketNo];
        while (null != cur){
            if (cur.key == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
    public boolean containsValue(int value){
        //注意：哈希桶是根据key来计算哈希地址的。
        //因此，找value,不能计算出value在哪个桶中
        //在value时，必须要遍历所有的桶
        for (int bucketNo = 0;bucketNo < capacity;bucketNo++){
            Node cur = table[bucketNo];
            while (null != cur){
                if (cur.value == value){
                    return true;
                }
                cur = cur.next;
            }
        }
        return false;
    }
    public int size(){
        return size;
    }
    public boolean empty(){
        return 0 == size;
    }
    private void resize(){
        if (size*10/capacity > loadFact*10){
            int newCap = capacity*2;
            Node[] newTable = new Node[capacity*2];
            for (int i = 0;i<capacity;++i){
                Node cur = table[i];
                while (null != cur){
                    table[i] = cur.next;
                    int bucketNo = cur.key % newCap;
                    cur.next = newTable[bucketNo];
                    newTable[bucketNo] = cur;
                    cur = table[i];
                }
            }
            table = newTable;
            capacity = newCap;
        }
    }
    private int hashFunc(int key){
        return key % capacity;
    }
    public  void PrintHasnBucket(){
        for (int bucketNo = 0;bucketNo < capacity;++bucketNo){
            System.out.printf("table[%d]-->",bucketNo);
            Node cur = table[bucketNo];
            while (null!=cur){
                System.out.print("["+cur.key+","+cur.value+"]--->");
                cur = cur.next;
            }
            System.out.println("null");
        }
    }
    public static void main(String[] args) {
        HashBucket ht = new HashBucket(5);
        ht.put(1,1);
        ht.put(11,1);
        ht.put(2,2);
        ht.put(22,22);
        ht.put(6,6);
        ht.put(5,5);
        ht.put(51,51);
        ht.put(8,8);
        System.out.println(ht.size());
        ht.PrintHasnBucket();
        ht.put(3,3);
        ht.PrintHasnBucket();
        System.out.println(ht.containsKey(5));
        System.out.println(ht.containsValue(15));
        ht.remove(5);
        System.out.println(ht.containsKey(5));
        ht.PrintHasnBucket();
    }
}
/*
打印结果：
8
table[0]-->null
table[1]-->[51,51]--->[11,1]--->[1,1]--->null
table[2]-->[22,22]--->[2,2]--->null
table[3]-->null
table[4]-->null
table[5]-->[5,5]--->null
table[6]-->[6,6]--->null
table[7]-->null
table[8]-->[8,8]--->null
table[9]-->null
table[0]-->null
table[1]-->[51,51]--->[11,1]--->[1,1]--->null
table[2]-->[22,22]--->[2,2]--->null
table[3]-->[3,3]--->null
table[4]-->null
table[5]-->[5,5]--->null
table[6]-->[6,6]--->null
table[7]-->null
table[8]-->[8,8]--->null
table[9]-->null
true
false
false
table[0]-->null
table[1]-->[51,51]--->[11,1]--->[1,1]--->null
table[2]-->[22,22]--->[2,2]--->null
table[3]-->[3,3]--->null
table[4]-->null
table[5]-->null
table[6]-->[6,6]--->null
table[7]-->null
table[8]-->[8,8]--->null
table[9]-->null
*/