JAVA數據結構--哈希表的實現（分離鏈接法）

哈希表（散列）的定義

散列表（Hash table，也叫哈希表），是根據關鍵碼值(Key value)而直接進行訪問的數據結構。也就是說，它通過把關鍵碼值映射到表中一個位置來訪問記錄，以加快查找的速度。這個映射函數叫做散列函數，存放記錄的數組叫做散列表。

哈希表的特點是采用以常數平均時間執行插入、刪除和查找。

一個通俗的例子是，為了查找電話簿中某人的號碼，可以創建一個按照人名首字母順序排列的表（即建立人名到首字母的一個函數關系），在首字母為W的表中查找“王”姓的電話號碼，顯然比直接查找就要快得多。這里使用人名作為關鍵字，“取首字母”是這個例子中散列函數的函數法則，存放首字母的表對應散列表。關鍵字和函數法則理論上可以任意確定。

分離鏈接法定義

將散列到同一個值得所有元素保留到一個表中。

基本思想是采用N個鏈表組成鏈表數組，N為哈希表的長度。

哈希表構造實現

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 void insert(T x) {
        List<T> whichList=theLists[myhash(x)];
        /*
         * 如果當前哈希地址的鏈表不含有元素，則鏈表中添加該元素
         * */
        if(!whichList.contains(x)) {
            whichList.add(x);
            if(++currentSize>theLists.length)//如果表長度不夠，則擴容
                rehash();
        }
    }
    public void remove(T x) {
        List<T> whichList=theLists[myhash(x)];
        if(whichList.contains(x)) {
            whichList.remove(x);
            currentSize--;
        }
    }
    public boolean contains(T x) {
        List<T> whilchList=theLists[myhash(x)];
        return whilchList.contains(x);
    }
    public void makeEmpty() {
        for(int i=0;i<theLists.length;i++)
            theLists[i].clear();
        currentSize=0;
    }

哈希表相關實現

private void rehash() {
        List<T>[] oldLists=theLists;
        theLists=new List[nextPrime(2*theLists.length)];
        for(int j=0;j<theLists.length;j++)
            theLists[j]=new LinkedList<>();
        
        currentSize=0;
        /*
         * 更新哈希表
         * */
        for(List<T> list:oldLists)
            for(T item:list)
                insert(item);
    }
    /*
     * myhash()方法獲得哈希表的地址
     * */
    private int myhash(T x) {
        int hashVal=x.hashCode();//hashCode()方法返回該對象的哈希碼值
        hashVal%=theLists.length;//對哈希表長度取余數
        if(hashVal<0)
            hashVal+=theLists.length;
        return hashVal;
    }

全部代碼

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

public class SeparateChainingHashTable<T>{
    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 void insert(T x) {
        List<T> whichList=theLists[myhash(x)];
        /*
         * 如果當前哈希地址的鏈表不含有元素，則鏈表中添加該元素
         * */
        if(!whichList.contains(x)) {
            whichList.add(x);
            if(++currentSize>theLists.length)//如果表長度不夠，則擴容
                rehash();
        }
    }
    public void remove(T x) {
        List<T> whichList=theLists[myhash(x)];
        if(whichList.contains(x)) {
            whichList.remove(x);
            currentSize--;
        }
    }
    public boolean contains(T x) {
        List<T> whilchList=theLists[myhash(x)];
        return whilchList.contains(x);
    }
    public void makeEmpty() {
        for(int i=0;i<theLists.length;i++)
            theLists[i].clear();
        currentSize=0;
    }
    
    private static final int DEFAULT_TABLE_SIZE=101;
    
    private List<T> [] theLists;
    private int currentSize;
    
    /*
     * 哈希表擴容，表長度為下一個素數
     * */
    private void rehash() {
        List<T>[] oldLists=theLists;
        theLists=new List[nextPrime(2*theLists.length)];
        for(int j=0;j<theLists.length;j++)
            theLists[j]=new LinkedList<>();
        
        currentSize=0;
        /*
         * 更新哈希表
         * */
        for(List<T> list:oldLists)
            for(T item:list)
                insert(item);
    }
    /*
     * myhash()方法獲得哈希表的地址
     * */
    private int myhash(T x) {
        int hashVal=x.hashCode();//hashCode()方法返回該對象的哈希碼值
        hashVal%=theLists.length;//對哈希表長度取余數
        if(hashVal<0)
            hashVal+=theLists.length;
        return hashVal;
    }
    //下一個素數
    private static int nextPrime(int n) {
        if( n % 2 == 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 % 2 == 0 )
                return false;

            for( int i = 3; i * i <= n; i += 2 )
                if( n % i == 0 )
                    return false;

            return true;
    }
}