設計並實現一個散列表

時間 2019-11-12

標籤設計實現一個列表简体版

原文原文鏈接

1.HashMap的數據結構

　　數組的特色是：尋址容易，插入和刪除困難；而鏈表的特色是：尋址困難，插入和刪除容易。那麼咱們能不能綜合二者的特性，作出一種尋址容易，插入刪除也容易的數據結構？答案是確定的，這就是咱們要提起的哈希表，哈希表有多種不一樣的實現方法，我接下來解釋的是最經常使用的一種方法—— 拉鍊法，咱們能夠理解爲「鏈表的數組」，如圖：java

　　從上圖咱們能夠發現哈希表是由數組+鏈表組成的，一個長度爲16的數組中，每一個元素存儲的是一個鏈表的頭結點。那麼這些元素是按照什麼樣的規則存儲到數組中呢。通常狀況是經過hash(key)%len得到，也就是元素的key的哈希值對數組長度取模獲得。好比上述哈希表中，12%16=12,28%16=12,108%16=12,140%16=12。因此十二、2八、108以及140都存儲在數組下標爲12的位置。算法

　　HashMap其實也是一個線性的數組實現的,因此能夠理解爲其存儲數據的容器就是一個線性數組。這可能讓咱們很不解，一個線性的數組怎麼實現按鍵值對來存取數據呢？這裏HashMap有作一些處理。數組

　　1.首先HashMap裏面實現一個靜態內部類Entry，其重要的屬性有 key , value, next，從屬性key,value咱們就能很明顯的看出來Entry就是HashMap鍵值對實現的一個基礎bean，咱們上面說到HashMap的基礎就是一個線性數組，這個數組就是Entry[]，Map裏面的內容都保存在Entry[]裏面。數據結構

2.HashMap的存取實現

既然是線性數組，爲何能隨機存取？這裏HashMap用了一個小算法，大體是這樣實現：app

//存儲時:
int hash = key.hashCode();// 這個hashCode方法這裏不詳述,只要理解每一個key的hash是一個固定的int值
int index = hash % Entry[].length;
Entry[index] = value;

//取值時:
int hash = key.hashCode();
int index = hash % Entry[].length;
return Entry[index];

到這裏咱們輕鬆的理解了HashMap經過鍵值對實現存取的基本原理函數

3.疑問：若是兩個key經過hash%Entry[].length獲得的index相同，會不會有覆蓋的危險？性能

　　這裏HashMap裏面用到鏈式數據結構的一個概念。上面咱們提到過Entry類裏面有一個next屬性，做用是指向下一個Entry。打個比方，第一個鍵值對A進來，經過計算其key的hash獲得的index=0，記作:Entry[0] = A。一會後又進來一個鍵值對B，經過計算其index也等於0，如今怎麼辦？HashMap會這樣作:B.next = A,Entry[0] = B,若是又進來C,index也等於0,那麼C.next = B,Entry[0] = C；這樣咱們發現index=0的地方其實存取了A,B,C三個鍵值對,他們經過next這個屬性連接在一塊兒。因此疑問不用擔憂。也就是說數組中存儲的是最後插入的元素。到這裏爲止，HashMap的大體實現，咱們應該已經清楚了。優化

　　固然HashMap裏面也包含一些優化方面的實現，這裏也說一下。好比：Entry[]的長度必定後，隨着map裏面數據的愈來愈長，這樣同一個 index的鏈就會很長，會不會影響性能？HashMap裏面設置一個因素（也稱爲因子），隨着map的size愈來愈大，Entry[]會以必定的規則加長長度。spa

3.解決hash衝突的辦法

開放定址法（線性探測再散列，二次探測再散列，僞隨機探測再散列）
再哈希法
鏈地址法
創建一個公共溢出區

Java中hashmap的解決辦法就是採用的鏈地址法。.net

4.實現本身的HashMap

Entry.java

package edu.sjtu.erplab.hash;

public class Entry<K,V>{
    final K key;
    V value;
    Entry<K,V> next;//下一個結點
 
    //構造函數
    public Entry(K k, V v, Entry<K,V> n) {
        key = k;
        value = v;
        next = n;
    }

    public final K getKey() {
        return key;
    }

    public final V getValue() {
        return value;
    }

    public final V setValue(V newValue) {
    V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {
        if (!(o instanceof Entry))
            return false;
        Entry e = (Entry)o;
        Object k1 = getKey();
        Object k2 = e.getKey();
        if (k1 == k2 || (k1 != null && k1.equals(k2))) {
            Object v1 = getValue();
            Object v2 = e.getValue();
            if (v1 == v2 || (v1 != null && v1.equals(v2)))
                return true;
        }
        return false;
    }

    public final int hashCode() {
        return (key==null   ? 0 : key.hashCode()) ^ (value==null ? 0 : value.hashCode());
    }

    public final String toString() {
        return getKey() + "=" + getValue();
    }

}

MyHashMap.java

package edu.sjtu.erplab.hash;

//保證key與value不爲空
public class MyHashMap<K, V> {
    private Entry[] table;//Entry數組表
    static final int DEFAULT_INITIAL_CAPACITY = 16;//默認數組長度
    private int size;

    // 構造函數
    public MyHashMap() {
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        size = DEFAULT_INITIAL_CAPACITY;
    }

    //獲取數組長度
    public int getSize() {
        return size;
    }
    
    // 求index
    static int indexFor(int h, int length) {
        return h % (length - 1);
    }

    //獲取元素
    public V get(Object key) {
        if (key == null)
            return null;
        int hash = key.hashCode();// key的哈希值
        int index = indexFor(hash, table.length);// 求key在數組中的下標
        for (Entry<K, V> e = table[index]; e != null; e = e.next) {
            Object k = e.key;
            if (e.key.hashCode() == hash && (k == key || key.equals(k)))
                return e.value;
        }
        return null;
    }

    // 添加元素
    public V put(K key, V value) {
        if (key == null)
            return null;
        int hash = key.hashCode();
        int index = indexFor(hash, table.length);

        // 若是添加的key已經存在，那麼只須要修改value值便可
        for (Entry<K, V> e = table[index]; e != null; e = e.next) {
            Object k = e.key;
            if (e.key.hashCode() == hash && (k == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                return oldValue;// 原來的value值
            }
        }
        // 若是key值不存在，那麼須要添加
        Entry<K, V> e = table[index];// 獲取當前數組中的e
        table[index] = new Entry<K, V>(key, value, e);// 新建一個Entry，並將其指向原先的e
        return null;
    }

}

MyHashMapTest.java

package edu.sjtu.erplab.hash;

public class MyHashMapTest {

    public static void main(String[] args) {

        MyHashMap<Integer, Integer> map = new MyHashMap<Integer, Integer>();
        map.put(1, 90);
        map.put(2, 95);
        map.put(17, 85);
    
        System.out.println(map.get(1));
        System.out.println(map.get(2));
        System.out.println(map.get(17));
        System.out.println(map.get(null));
    }
}

散列表有兩個重點問題：一、如何將一個數字映射到數組下標；

二、如何處理衝突問題？

ok，鑑於這是演示簡單的哈希表，散列函數這樣定義：

index=key%16;

而衝突的處理如何：

當映射到的位置同樣，就將相關數據壓入同一位置的鏈表。

核心代碼以下：

[java] view plain copy

print ?