706_Design_HashMap

qiyuangong · qiyuangong · commit b0cc0717607b · 2018-12-01T15:57:13.000+08:00
diff --git a/README.md b/README.md
@@ -151,6 +151,7 @@ Also, there are open source implementations for basic data structs and algorithm
 | 617 | [Merge Two Binary Trees](https://leetcode.com/problems/merge-two-binary-trees/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/617_Merge_Two_Binary_Trees.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/617_Merge_Two_Binary_Trees.java) | Traverse both trees Recursion & Iterative (stack) |
 | 654 | [Maximum Binary Tree](https://leetcode.com/problems/maximum-binary-tree/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/654_Maximum_Binary_Tree.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/654_Maximum_Binary_Tree.java) | 1. Divide and conquer, recursive, O(n^2)<br>2. Monotonic stack, O(n) |
 | 697 | [Degree of an Array](https://leetcode.com/problems/degree-of-an-array/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/697_Degree_of_an_Array.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/697_Degree_of_an_Array.java) | 1. Find degree and value, then find smallest subarray (start and end with this value), O(n) and O(n)<br>2. Go through nums, remember left most pos and right most for each value, O(n) and O(n) |
+| 706 | [Design HashMap](https://leetcode.com/problems/design-hashmap/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/706_Design_HashMap.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/@706_Design_HashMap.java) | Hash implementation, mod is fine. Be careful about key conflict and key remove. |
 | 709 | [To Lower Case](https://leetcode.com/problems/to-lower-case/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/709_To_Lower_Case.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/709_To_Lower_Case.java) | String processing:<br>1. str.lower() or str.toLowerCase()<br>2. ASCII processing. O(n) and O(1) |
 | 716 | [Max Stack](https://leetcode.com/problems/max-stack/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/716_Max_Stack.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/716_Max_Stack.java) | 1. Two stacks<br> 2. Double linked list and Hash |
 | 720 | [Longest Word in Dictionary](https://leetcode.com/problems/longest-word-in-dictionary/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/720_Longest_Word_in_Dictionary.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/720_Longest_Word_in_Dictionary.java) | 1. Brute Force, O(sum(w^2)) and O(w)<br>2. Tire Tree, O(sum(w) and O(w))<br>3. Sort and word without last char, O(nlogn + sum(w)) and O(w) |
diff --git a/create_empty_files.py b/create_empty_files.py
@@ -0,0 +1,14 @@
+import sys
+
+if __name__ == '__main__':
+    file_name = 'test'
+    try:
+        file_name = sys.argv[1]
+    except IndexError:
+        print("Usage: python create_empty_file [filename]")
+    print("Creating " + file_name + "in java and python dir...")
+    with open("python/" + file_name + ".py", 'w'):
+        pass
+    with open("java/" + file_name + ".java", 'w'):
+        pass
+    print("Done!")
diff --git a/java/706_Design_HashMap.java b/java/706_Design_HashMap.java
@@ -0,0 +1,50 @@
+class MyHashMap {
+    final ListNode[] nodes = new ListNode[10000];
+    // https://leetcode.com/problems/design-hashmap/discuss/152746/Java-Solution
+    public void put(int key, int value) {
+        int i = idx(key);
+        if (nodes[i] == null)
+            nodes[i] = new ListNode(-1, -1);
+        ListNode prev = find(nodes[i], key);
+        if (prev.next == null)
+            prev.next = new ListNode(key, value);
+        else prev.next.val = value;
+    }
+
+    public int get(int key) {
+        int i = idx(key);
+        if (nodes[i] == null)
+            return -1;
+        ListNode node = find(nodes[i], key);
+        return node.next == null ? -1 : node.next.val;
+    }
+
+    public void remove(int key) {
+        int i = idx(key);
+        if (nodes[i] == null) return;
+        ListNode prev = find(nodes[i], key);
+        if (prev.next == null) return;
+        prev.next = prev.next.next;
+    }
+
+    int idx(int key) { return Integer.hashCode(key) % nodes.length;}
+
+    ListNode find(ListNode bucket, int key) {
+        ListNode node = bucket, prev = null;
+        while (node != null && node.key != key) {
+            prev = node;
+            node = node.next;
+        }
+        return prev;
+    }
+
+    class ListNode {
+        int key, val;
+        ListNode next;
+
+        ListNode(int key, int val) {
+            this.key = key;
+            this.val = val;
+        }
+    }
+}
diff --git a/python/706_Design_HashMap.py b/python/706_Design_HashMap.py
@@ -0,0 +1,80 @@
+class MyHashMap(object):
+
+    # https://leetcode.com/problems/design-hashmap/discuss/152746/Java-Solution
+    def __init__(self):
+        """
+        Initialize your data structure here.
+        """
+        self.size = 10000
+        self.nodes = [None] * self.size
+
+    def put(self, key, value):
+        """
+        value will always be non-negative.
+        :type key: int
+        :type value: int
+        :rtype: void
+        """
+        index = hash(key) % self.size
+        if self.nodes[index] is None:
+            self.nodes[index] = ListNode(-1, -1)
+        prev = find(self.nodes[index], key)
+        if prev.next is None:
+            prev.next = ListNode(key, value)
+        else:
+            prev.next.val = value
+
+    def get(self, key):
+        """
+        Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key
+        :type key: int
+        :rtype: int
+        """
+        index = hash(key) % self.size
+        if self.nodes[index] is None:
+            return -1
+        prev = find(self.nodes[index], key)
+        if prev.next is None:
+            return -1
+        else:
+            return prev.next.val
+
+    def remove(self, key):
+        """
+        Removes the mapping of the specified value key if this map contains a mapping for the key
+        :type key: int
+        :rtype: void
+        """
+        index = hash(key) % self.size
+        if self.nodes[index] is None:
+            return
+        prev = find(self.nodes[index], key)
+        if prev.next is None:
+            return
+        prev.next = prev.next.next
+
+
+def find(bucket, key):
+    # find prev node of this key
+    node = bucket
+    prev = None
+    while node is not None and node.key != key:
+        prev = node
+        node = node.next
+    return prev
+
+
+# Basic node in hash map
+class ListNode():
+
+    def __init__(self, key, val):
+        self.key = key
+        self.val = val
+        self.next = None
+
+
+# Your MyHashMap object will be instantiated and called as such:
+# obj = MyHashMap()
+# obj.put(key,value)
+# param_2 = obj.get(key)
+# obj.remove(key)
