5，常见数据结构-散列表

想了解更多数据结构以及算法题，可以关注微信公众号“数据结构和算法”，每天一题为你精彩解答。也可以扫描下面的二维码关注

基础知识

散列表也叫哈希表，是根据键值对（key，value）进行访问的一种数据结构。他是把一对（key，value）通过key的哈希值来映射到数组中的，也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

1，HashMap

散列表中最常见的应该就是HashMap了，HashMap的实现原理非常简单，他其实就是数组加链表的一种数据结构。如果映射在数组中出现了冲突，他会以链表的形式存在。我们来看一下他的数据结构是什么样的。

上面的图有两处非常明显的错误，不知道大家有没有发现，如果对HashMap源码比较熟悉的估计一眼就能看的出来。首先是数组的长度必须是2的n次幂，这里长度是9，明显有错，然后是entry的个数不能大于数组长度的75%，如果大于就会触发扩容机制进行扩容，这里明显是大于75%。我为什么要画这个错误的图呢，因为在网上确实看到过不少这样不严谨的图，希望大家能够看清楚。那么正确的图应该是这样的。

数组的长度即是2的n次幂，而他的size又不大于数组长度的75%。

HashMap的实现原理是先要找到要存放数组的下标，如果是空的就存进去，如果不是空的就判断key值是否一样，如果一样就替换，如果不一样就以链表的形式存在。

在java中1.7及以前的版本如果以链表的形式存在，在插入的时候采用的是头插法。

在1.8是尾插法。并且在java1.8中如果链表的长度大于8的时候会转为红黑树。

在HashMap中，数组的大小是2^{n，无论你初始化的时候传的值是多少，他都会初始化为2}n，并且这个2^n是大于等于你初始化值的最小值，比如初始化的时候传的值是17，他会计算得到32。关于怎么计算的，我们有3种方式，第一种就是通过while循环，我们来看下代码

public static int tableSizeFor(int initialCapacity) {
    int capacity = 1;
    while (capacity < initialCapacity)
        capacity <<= 1;
    return capacity;
}

这种解法是最简单的，一眼就能看懂，还有两种解法我们也可以看下

public static int tableSizeFor(int i) {
    i--;
    i |= i >>> 1;
    i |= i >>> 2;
    i |= i >>> 4;
    i |= i >>> 8;
    i |= i >>> 16;
    return i + 1;
}

原理比较简单，就是把最左边的1往右全部铺开，最后在加上1就是我们要求的结果。这里第二行减1的目的是防止i等于2^n的时候结果会放大。比如当i=32的时候如果我们在第2行不减1，会导致结果为64。我们再来看另一种写法

 public static int tableSizeFor(int i) {
     if ((i & (i - 1)) == 0)
         return i;
     i |= (i >> 1);
     i |= (i >> 2);
     i |= (i >> 4);
     i |= (i >> 8);
     i |= (i >> 16);
     return (i - (i >>> 1)) << 1;
}

在第2-3行实现判断是不是2^n， 如果是就直接返回，第4-8行也是把i最左边的1往右全部铺开，第9行i-(i>>>1)表示的是把i最左边的1保留，其他的全部置为0，通俗一点也就是他返回的是小于i的最大的2^n，然后再往左移一位就是我们要求的结果。我们就以i等于17为例用最后一个方法来画个图分析一下。

2，ArrayMap

除了使用数组和链表以外，我们能不能只使用一种数据结构呢，比如数组，当然也是可以的。大家可能会怀疑，如果只使用一种数据结构的话，映射出现了冲突怎么办，其实也很好解决。ArrayMap的实现原理是使用两个数组，一个存放hash值，一个存放key和value，其中存放key和value的数组长度是存放hash值数组长度的二倍，其中存放hash值的数组必须是排序的。如果hash值出现了冲突，说明hash值最终的计算是一样的，那么在hash数组中肯定是挨着的，所以查找的时候如果hash值有重复的就会把重复的也查找一遍。我们来看ArrayMap中的一段代码

 int indexOf(Object key, int hash) {
     final int N = mSize;
 
     // Important fast case: if nothing is in here, nothing to look for.
     if (N == 0) {
         return ~0;
     }
 
     int index = binarySearchHashes(mHashes, N, hash);

    // If the hash code wasn't found, then we have no entry for this key.
    if (index < 0) {
        return index;
    }

    // If the key at the returned index matches, that's what we want.
    if (key.equals(mArray[index<<1])) {
        return index;
    }

    // Search for a matching key after the index.
    int end;
    for (end = index + 1; end < N && mHashes[end] == hash; end++) {
        if (key.equals(mArray[end << 1])) return end;
    }

    // Search for a matching key before the index.
    for (int i = index - 1; i >= 0 && mHashes[i] == hash; i--) {
        if (key.equals(mArray[i << 1])) return i;
    }

    // Key not found -- return negative value indicating where a
    // new entry for this key should go.  We use the end of the
    // hash chain to reduce the number of array entries that will
    // need to be copied when inserting.
    return ~end;
}

我们看到第23-30行，如果hash值一样，在查找的时候不光往前查找而且还会往后查找。他的数据结构是这样的。

3，SparseArray

在散列表中如果可以确定key值都是int类型，那么又可以简化，直接用key值当hash值存储即可，和ArrayMap一样只需要两个数组即可，一个是存放key的，一个是存放value的，不同的是这两个数组的长度都是一样的。这种情况下就不会出现hash值一样的问题了，因为这个时候如果hash值一样的话，那么他们的key肯定是一样的，而在散列表中是不可能存在了，假如在插入数据的时候有一样的key，那么他的value是要被替换掉的，所以不会出现两个完全一样的key。他的数据结构图是这样的

4，ThreadLocalMap

在java语言中还有一个关于散列表的，那就是ThreadLocalMap，这个类是ThreadLocal的一个静态内部类，一般我们用不到。如果出现hash冲突的时候他的实现原理和上面的几种也都不太一样。存储的时候他首先会根据hash值映射到指定的数组，如果当前位置为空就直接存进去，如果不为空就往后找，找他的下一个，我们来看其中的一段代码

    /**
     * Increment i modulo len.
     */
    private static int nextIndex(int i, int len) {
        return ((i + 1 < len) ? i + 1 : 0);
    }

总结：
散列表大家第一个想到的就是HashMap，需要数组加链表的方式才能实现，通过我们上面的分析，其实我们不需要链表也能实现。散列表的实现原理其实很简单。他的核心是当我们的hash值出现冲突的时候该怎么解决。