第5章 散列

一个好的散列函数

    public static int hash(String key, int tableSize)
    {
        int hashVal = 0;
        
        for (int i = 0; i < key.length(); i++)
            hashVal = 37 * hashVal + key.charAt(i);
        
        hashVal %= tableSize;
        if (hashVal < 0)
            hashVal += tableSize;
        
        return hashVal;
    }

如果当一个元素被插入时与一个已经插入的元素散列到相同的值，那么就产生一个冲突，这个冲突需要消除。解决这种冲突的方法有几种，其中最简单的两种：分离链接法和开放地址法

分离链接法

import java.util.LinkedList;
import java.util.List;

public class SeparateChainingHashTable<AnyType>
{
    public SeparateChainingHashTable()
    { this(DEFAULT_TABLE_SIZE); }
    public SeparateChainingHashTable(int size)
    {
        theLists = new LinkedList[nextPrime(size)];
        for (int i = 0; i < theLists.length; i++)
            theLists[i] = new LinkedList<>();
    }

    public boolean contains(AnyType x)
    {
        List<AnyType>whichList = theLists[myhash(x)];
        return whichList.contains(x);
    }

    public void insert(AnyType x)
    {
        List<AnyType>whichList = theLists[myhash(x)];
        if (!whichList.contains(x))
        {
            whichList.add(x);

            if (++currentSize > theLists.length)
                rehash();
        }
    }

    public void remove(AnyType x)
    {
        List<AnyType>whichList = theLists[myhash(x)];
        if (whichList.contains(x))
        {
            whichList.remove(x);
            currentSize--;
        }
    }

    public void makeEmpty()
    {
        for (int i = 0; i < theLists.length; i++)
            theLists[i].clear();

        currentSize = 0;
    }

    private int currentSize;
    private List<AnyType>[] theLists;
    private static final int DEFAULT_TABLE_SIZE = 101;

    private void rehash()
    {
        List<AnyType>[] oldLists = theLists;

        theLists = new List[nextPrime( 2 * theLists.length)];
        for (int i = 0; i < theLists.length; i++)
            theLists[i] = new LinkedList<>();

        currentSize = 0;
        for (int i = 0; i < oldLists.length; i++)
            for (AnyType item : oldLists[i])
                insert(item);
    }

    private int myhash(AnyType x)
    {
        int hashVal = x.hashCode();

        hashVal %= theLists.length;
        if (hashVal < 0)
            hashVal += theLists.length;

        return hashVal;
    }

    private static boolean isPrime(int n)
    {
        if (n == 2 || n == 3)
            return true;
        if (n == 1 || (n&1) == 0)
            return false;
        for (int i = 3; i * i < n; i++)
            if (n % i == 0)
                return false;

        return true;
    }

    private static int nextPrime(int n)
    {
        if (n % 2 == 0)
            n++;
        for (; !isPrime(n); n += 2)
            ;
        return n;
    }
}

5.4 不用链表的散列表

5.4.1 线性探测法

只要表足够大，总能够找到一个自由单元，但是如此花费的时间是相当多的。更糟的是，即使表相对较空，这样占据的单元也会开始形成一些区块，其结果称为一次聚集，就是说，散列到区块中的任何关键字都需要多次试选单元才能够解决冲突，然后该关键字被添加到相应的区块中。

5.4.2 平方探测法

平方探测是消除线性探测中一次聚焦问题的冲突解决方法。虽然平方探测排除了一次聚集，但是散列到同一位置上的那些元素将探测相同的备选单元。这叫作二次聚集。 

public class QuadraticProbingHashTable<AnyType> {
    public QuadraticProbingHashTable() {
        this(DEFAULT_TABLE_SIZE);
    }

    public QuadraticProbingHashTable(int size) {
        allocateArray(size);
        makeEmpty();
    }

    public void makeEmpty() {
        currentSize = 0;
        for (int i = 0; i < array.length; i++)
            array[i] = null;
    }

    public boolean contains(AnyType x) {
        int currentPos = findPos(x);
        return isActive(currentPos);
    }

    public void insert(AnyType x) {
        int currentPos = findPos(x);
        if (isActive(currentPos))
            return;

        array[currentPos] = new HashEntry<>(x, true);
        if (currentPos > array.length / 2)
            rehash();
    }

    public void remove(AnyType x)
    {
        int currentPos = findPos(x);
        if (isActive(currentPos))
            array[currentPos].isActive = false;
    }
    
    private static class HashEntry<AnyType>
    {
        public AnyType element;
        public boolean isActive;

        public HashEntry(AnyType e)
        { this(e, true); }

        public HashEntry(AnyType e, boolean i)
        {
            element = e;
            isActive = i;
        }
    }

    private static final int DEFAULT_TABLE_SIZE = 101;

    private HashEntry<AnyType>[] array;
    private int currentSize;

    private void allocateArray(int arraySize)
    { array = new HashEntry[nextPrime(arraySize)]; }
    private int findPos(AnyType x)
    {
        int offest = 1;
        int currentPos = myhash(x);

        while (array[currentPos] != null && !array[currentPos].element.equals(x))
        {
            currentPos += offest;
            offest += 2;
            if (currentPos >= array.length)
                currentPos -= array.length;
        }
        return currentPos;
    }
    private boolean isActive(int currentPos)
    { return array[currentPos] != null && array[currentPos].isActive; }
    private void rehash()
    {
        HashEntry<AnyType>[] oldArray = array;
        allocateArray(nextPrime(2 * array.length));
        currentSize = 0;

        for (int i = 0; i < oldArray.length; i++)
            if (oldArray[i] != null && oldArray[i].isActive)
                insert(oldArray[i].element);
    }

    private int myhash(AnyType x)
    {
        int hashVal = x.hashCode();

        hashVal %= array.length;
        if (hashVal < 0)
            hashVal += array.length;

        return hashVal;
    }

    private static int nextPrime(int n)
    {
        if ((n&1) == 0)
            n++;

        for (; !isPrime(n); n += 2)
            ;

        return n;
    }

    private static boolean isPrime(int n)
    {
        if (n == 2 || n == 3)
            return true;
        if (n == 1 || (n&1) == 0)
            return false;
        for (int i = 3; i * i <= n; i++)
            if (n % i == 0)
                return false;

        return true;
    }
}

5.4.3 双散列 最后一个冲突解决方法

5.5 再散列 对于使用平方探测的开放定址散列法，如果散列表填的太满，那么操作的运行时间将开始消耗过长，且插入操作可能失败。这可能发生在有太多的移动和插入混合的场合。此时，一个解决方法是建立另外一个大约两倍大的表（而且使用一个相关的新散列函数），扫描整个原始散列表，计算每个（未删除）元素的新散列值并将其插入到新表中。

5.6 标准库中的散列表

HashSet和HashMap通常是用分离链接散列实现的。

5.7.2 布谷鸟散列

import java.util.Random;

public class CuckooHashTable<AnyType>
{
    public CuckooHashTable(HashFamily<? super AnyType>hf) { this(hf, DEFAULLT_TABLE_SIZE); }

    public CuckooHashTable(HashFamily<? super AnyType>hf, int size)
    {
        allocateArray(nextPrime(size));
        doClear();
        hashFunctions = hf;
        numHashFunctions = hf.getNumberOfFunctions();
    }

    private Random r = new Random();

    private static final double MAX_LOAD = 0.4;
    private static final int ALLOWED_REHASHES = 1;

    private int rehashes = 0;

   private boolean insertHelper1(AnyType x)
   {
       final int COUNT_LINIT = 100;
       
       while (true)
       {
           int lastPos = 1;
           int pos;
           for (int count = 0; count < COUNT_LINIT; count++)
           {
               for (int i = 0; i < numHashFunctions; i++)
               {
                   pos = myhash(x, i);
                   if (array[pos] == null)
                   {
                       array[pos] = x;
                       currentSize++;
                       return true;
                   }
               }
               int i = 0;
               do 
               {
                   pos = myhash(x, r.nextInt(numHashFunctions));
               }while (pos == lastPos && i++ < 5);
               
               AnyType tmp = array[lastPos = pos];
               array[pos] = x;
               x = tmp;
           }
           if (++rehashes > ALLOWED_REHASHES)
           {
               expand();
               rehashes = 0;
           }
           else
               rehash();
       }
   }
    

    public boolean insert(AnyType x)
    {
        if (contains(x))
            return false;
        if (currentSize >= array.length / MAX_LOAD)
            expand();
        return insertHelper1(x);
    }

    private int myhash(AnyType x, int which)
    {
        int hashVal = hashFunctions.hash(x, which);

        hashVal %= array.length;
        if (hashVal < 0)
            hashVal += array.length;

        return hashVal;
    }

    private void expand(){ rehash((int)(array.length / MAX_LOAD));}

    private void rehash()
    {
        hashFunctions.generateNewFunctions();
        rehash(array.length);
    }

    private void rehash(int newLength)
    {
        AnyType[] oldArray = array;
        allocateArray(nextPrime(newLength));

        currentSize = 0;

        for (AnyType str : oldArray)
            if (str != null)
                insert(str);
    }

    public int size(){ return currentSize; }

    public int capacity(){ return array.length; }

    private int findPos(AnyType x)
    {
        for (int i = 0; i < numHashFunctions; i++)
        {
            int pos = myhash(x, i);
            if (array[pos] != null && array[pos].equals(x))
                return pos;
        }
        return -1;
    }

    public boolean remove(AnyType x)
    {
        int pos = findPos(x);
        if (pos != -1)
        {
            array[pos] = null;
            currentSize--;
        }
        return pos != -1;
    }

    public boolean contains(AnyType x){ return findPos(x) != -1;}

    public void makeEmpty(){ doClear(); }

    private void doClear()
    {
        currentSize = 0;
        for (int i = 0; i < array.length; i++)
            array[i] = null;
    }

    private static final int DEFAULLT_TABLE_SIZE = 101;

    private final HashFamily<? super AnyType>hashFunctions;
    private final int numHashFunctions;
    private AnyType[] array;
    private int currentSize;

    private void allocateArray(int arraySize) { array = (AnyType[])new Object[arraySize]; }

    protected static int nextPrime(int n)
    {
        if ((n&1) == 0)
            n++;
        for (; !isPime(n); n += 2)
            ;
        return n;
    }

    private static boolean isPime(int n)
    {
        if (n == 2 || n == 3)
            return true;
        if (n == 1 || (n&1) == 0)
            return false;
        for (int i = 3; i * i <= n; i += 2)
            if (n % i == 0)
                return false;

        return true;
    }
}

5.7.3 跳房子散列的思路是，用事先确定的、对计算机的底层体系结构而言是最优的一个常数，给探测序列的最大长度加个上界。这样做可以给出常数级的最坏查询时间，并且与布谷鸟散列一样，查询可以并行化，以同时检查可用位置的有限集。