哈希表与HashMap

概念

顺序结构以及平衡树中，元素与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过元素的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O( log${}_2$N)，搜索的效率取决于搜索过程中元素的比较次数。

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

• 插入元素

根据函数计算出的存储位置进行存放

• 搜索元素

进行同样的计算，求得的函数值为元素的存储位置，进行元素比较，若相等，则搜索成功

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

例如：数据集合{1，54，15，89，66}；

用该方法搜索不必进行多次比较，因此搜索的速度比较快 .
问题：按照上述哈希函数插入元素44，会出现什么问题？

冲突

概念

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

避免

由于哈希表底层数组的容量往往小于实际要存储的数量，这就导致冲突的发生是必然的，我们能做的是尽量降低冲突率。

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

• 哈希函数的定义域必须包括需要存储的全部数据
• 哈希函数计算出来的地址能均匀分布在整个空间中
• 哈希函数应该比较简单

常见哈希函数

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

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

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

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

3. 平方取中法(了解)

假设数据为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址； 再比如数据为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址 平方取中法比较适合不知道数据的分布，而位数又不是很大的情况

4. 折叠法(了解)

折叠法是将数据从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。
折叠法适合事先不需要知道数据的分布，适合位数比较多的情况

5. 随机数法–(了解)

选择一个随机函数，数据的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。
通常应用于数据长度不等时采用此法

7. 数学分析法(了解)

设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。例如：
假设要存储某家公司员工登记表，如果用手机号作为比较，那么极有可能前几位都是相同的，那么我们可以选择后面的几位作为散列地址，如果这样的抽取工作还容易出现冲突，还可以对抽取出来的数字进行反转(如1234改成4321)、右环位移(如1234改4123)、左环移位、前两数与后两数叠加(如1234改成12+34=46)等方法。
数字分析法通常适合处理数据位数比较大的情况，如果事先知道数据的分布且数据的若干位分布较均匀的情况

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

负载因子调节

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

解决

解决哈希冲突两种常见的方法是：闭散列和开散列

闭散列

闭散列也叫开放定址法，当发生哈希冲突时，如果哈希表还有空位置，那么可以把冲突的数据存放到冲突位置中的“下一个” 空位置中去。那如何寻找下一个空位置呢？

1. 线性探测

比如之前的例子需要插入14，先通过哈希函数计算下标为4，该位置已经放了值为54的元素，即发生哈希冲突。
线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

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

2.二次探测

线性探测的缺陷是产生冲突的数据堆积在一块，这样搜索的效率就低了,因为无法通过函数直接确定位置,要遍历去找。
二次探测为了避免该问题，找下一个空位置的方法为：H${}_i$ = ( H${}_0$+ i${}^2$ )% capacity, 或者：H${}_i$ = (H${}_0$ - i${}^2$)% capacity。其中：i = 1,2,3… ; H${}_0$为冲突位置

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

开散列/哈希桶（重点掌握）

开散列法又叫链地址法(开链法)，首先对数据集合用散列函数计算散列地址，具有相同地址的数据归于同一子集合，每一个子集合称为一个桶，桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。

开散列，可以认为是把一个在大集合中的搜索问题转化为在小集合中做搜索了。

冲突严重时的解决办法

刚才我们提到了，哈希桶将大集合的搜索问题转化为小集合的搜索问题了，如果冲突严重(小集合的搜索性能也不行)，这个时候我们可以将小集合搜索问题继续进行转化，例如：

1. 每个桶的背后是另一个哈希表
2. java的HashMap中,如果数组长度>=64 && 链表长度 >= 8,链表变成红黑树

求平均查找长度

1.设哈希表长度为11,哈希函数H(K)=(第一个字母在字母表中的序号)K%11,若输入顺序为(D,BA,TN,M,CI,I,K,X,TA),采用内散列表,处理冲突方法为线性探测法,要求构造哈希表,在等概率情况下查找成功平均查找长度为()
A. 4 B. 3 C. 20/9 D. 23/9

字母表

$\frac{1+4+1+2+1+3+5+1+2}{9}$ =20/9

选C

2.设哈希表长度为11,已知有一个关键字序列：（19,14,23,1,68,20,84,27,55,11,10,79）散列存储在一个哈希表中，若散列函数为H（key）=key%7，并采用链地址法来解决冲突，则在等概率情况下查找成功的平均查找长度为()
A.1.5 B.1.7 C.2.0 D.2.3

$\frac{1\times 7+2\times 4+3\times 1}{12}$ =1.5

HashMap简单实现(哈希函数:hash(key) = key % capacity(数组长度))

1.节点的key和value都是int

class HashBuck {
	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 = new Node[10];//初始哈希表大小
    public int usedSize;
    public static final double  LOAD_FACTOR = 0.75;//最大能忍受的负载因子


    public void push(int key,int val) {

        Node node = new Node(key,val);
        //1、找到位置
        int index = key % array.length;
        //2、遍历数组
        Node cur = array[index];
        while (cur != null) {
            if(cur.key == key) {
                //更新val
                cur.val = val;
                return;
            }
            cur = cur.next;
        }
        //头插法
        node.next = array[index];
        array[index] = node;
        usedSize++;
        if( doLoadFactor() >= 0.75) {
            //负载因子大于等于0.75,重新哈希
            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;
                //记录下来cur.next,如果不空,在下一循环重新放入
                Node curNext = cur.next;
                //把cur头插到新数组
                cur.next = newArray[index];
                newArray[index] = cur;
                cur = curNext;
            }
        }
        //把数据给到原数组 array
        array = newArray;
    }

    private double doLoadFactor() {
        return usedSize*1.0 / array.length;
    }


    public int get(int key) {
        //1、找到位置
        int index = key % array.length;
        //2、遍历数组
        Node cur = array[index];
        while (cur != null) {
            if(cur.key == key) {
                return cur.val;
            }
            cur = cur.next;
        }
        return -1;
    }
 }

2.节点的key和value是泛型

自定义类型可以用hashCode()方法变成整数,但会有问题

class Student {
    public String id;

    public Student(String id) {
        this.id = id;
    }
}

public class Test {
    public static void main(String[] args) {
        Student student = new Student("123456");
        int hashcode1 = student.hashCode();
        System.out.println(hashcode1);
        
        Student student2 = new Student("123456");
        int hashcode2 = student2.hashCode();
        System.out.println(hashcode2);
    }
}

虽然值相同,但hashCode()计算出的值却不一样,所以需要重写hashCode(),这样求出来的值依赖于id。此外，自定义类型的比较需要重写equals

对于自定义类型建议:
1.实现comparable接口
2.重写equals方法
3.重写hashCode方法
4.重写toString方法

import java.util.Objects;


class Student {
    public String id;

    public Student(String id) {
        this.id = id;
    }

   
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(id, student.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

public class Test {
    public static void main(String[] args) {
        Student student = new Student("123456");
        int hashcode1 = student.hashCode();
        System.out.println(hashcode1);

        Student student2 = new Student("123456");
        int hashcode2 = student2.hashCode();
        System.out.println(hashcode2);
    }
}

实现如下:

class HashBuck <K,V>{

    static class Node<K,V> {
        public K key;
        public V val;
        public Node<K,V> next;

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

    public Node<K,V>[] array = (Node<K,V>[])new Node[10];//一般new Object数组
    public int usedSize;
    public static final double  LOAD_FACTOR = 0.75;

    public void push(K key,V val) {
        Node<K,V> node = new Node<K,V>(key, val);

        int hash = key.hashCode();
        int index = hash % array.length;

        Node<K,V> cur = array[index];

        while (cur != null) {
            if(cur.key.equals(key)) {
                cur.val = val;
                return;
            }
            cur = cur.next;
        }

        node.next = array[index];
        array[index] = node;
        usedSize++;
        //重新哈希
    }

    public V get(K key) {
        int hash = key.hashCode();
        int index = hash % array.length;
        Node<K,V> cur = array[index];
        while (cur != null) {
            if(cur.key.equals(key)) {
                return  cur.val;
            }
            cur = cur.next;
        }
        return null;
    }
}

分析

虽然哈希表一直在和冲突做斗争，但在实际使用过程中，我们认为哈希表的冲突率是不高的，冲突个数是可控的，也就是每个桶中的链表的长度是一个常数，所以，通常意义下，我们认为哈希表的插入/删除/查找时间复杂度是O(1) 。

和 java 集合框架的关系

1. HashMap 和 HashSet , 即 java 中利用哈希表实现 Map 和 Set
2. java 中使用哈希桶方式解决冲突
3. java 会在链表长度大于一定阈值后，将链表转变为搜索树（红黑树）
4. java 中计算哈希值实际上是调用 hashCode 方法，进行 key 的比较是调用 key 的 equals 方法。所以如果要用自定义类作为 HashMap 的 key 或者 HashSet 的值，必须重写 hashCode 和 equals 方法，而且要做到 equals 相等的对象，hashCode 一定是一致的。

HashMap

static final int MAXIMUM_CAPACITY = 1 << 30;//数组最大容量
static final float DEFAULT_LOAD_FACTOR = 0.75f;//负载因子
static final int TREEIFY_THRESHOLD = 8;//红黑树化条件1:链表长度>=8
static final int UNTREEIFY_THRESHOLD = 6;//解树化的条件
static final int MIN_TREEIFY_CAPACITY = 64;//红黑树化条件2:数组长度>=64

构造方法

• 无参构造
  

仅设置了默认负载因子，也就是上文提到的0.75。并没有进行数组的初始化操作。

• 仅设置初始容量的构造函数
  

它调用了另一个含两个参数的构造函数.指定了数组的大小，只不过这个大小会变成最接近的2次幂
比如:20变成32;1000变成1024

当n为2次幂时，会满足一个公式：(n - 1) & hash = hash % n，就可以用位运算代替取余运算，计算更加高效

• 设置初始容量和负载因子的构造函数
  

这个构造函数可以同时指定数组的大小和负载因子。

tableSizeFor 方法 

tableSizeFor是为了返回一个最接近cap且大于cap的二次幂的值

• 以Map进行初始化的构造函数
  

扩容机制

第一次调用put方法的时候,会调用resize方法进行内存分配,如果构造函数指定了初始容量,大小就是大于指定的初始容量的最接近的2次幂的值;如果没有传入初始容量,默认初始容量为16,之后如果要扩容是进行2倍扩容.此外,是进行尾插法