【Leetcode】706. Design HashMap

題目地址：

https://leetcode.com/problems/design-hashmap/

設計HashMap。可以模仿java源代碼的方式。開一個數組，每個位置存鏈表的頭結點。進來一個entry的時候算一下key模數組長度，然後將這個entry的key在對應的bucket搜索一下，如果搜不到則直接加在鏈表尾，否則覆蓋掉已經存在的value。代碼如下：

public class MyHashMap {
    class ListNode {
        int key, val;
        ListNode next;
        ListNode(int key, int val) {
            this.key = key;
            this.val = val;
        }
    }
    
    private ListNode[] listNodes;
    
    /** Initialize your data structure here. */
    public MyHashMap() {
        listNodes = new ListNode[7 * 13];
    }
    
    /** value will always be non-negative. */
    public void put(int key, int value) {
        int pos = key % listNodes.length;
        ListNode prev = listNodes[pos];
        if (prev == null) {
            listNodes[pos] = new ListNode(key, value);
            return;
        }
        
        if (prev.key == key) {
            prev.val = value;
            return;
        }
        
        while (prev.next != null && prev.next.key != key) {
            prev = prev.next;
        }
        
        if (prev.next == null) {
            prev.next = new ListNode(key, value);
        } else {
            prev.next.val = value;
        }
    }
    
    /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
    public int get(int key) {
        ListNode prev = listNodes[key % listNodes.length];
        if (prev == null) {
            return -1;
        }
        
        if (prev.key == key) {
            return prev.val;
        }
        
        while (prev.next != null && prev.next.key != key) {
            prev = prev.next;
        }
        
        if (prev.next == null) {
            return -1;
        } else {
            return prev.next.val;
        }
    }
    
    /** Removes the mapping of the specified value key if this map contains a mapping for the key */
    public void remove(int key) {
        ListNode prev = listNodes[key % listNodes.length];
        if (prev == null) {
            return;
        }
        
        if (prev.key == key) {
            listNodes[key % listNodes.length] = prev.next;
            return;
        }
    
        while (prev.next != null && prev.next.key != key) {
            prev = prev.next;
        }
    
        if (prev.next != null) {
            prev.next = prev.next.next;
        }
    }
}

時間複雜度最差會達到$O(n)$。

註解：
listNodes = new ListNode[7 * 13];之所以選擇$7*13$是因爲素數在做哈希的時候有較好的性能，能使得put進來的key儘可能均勻分佈在數組上。