feat: add solutions to lc problems: No.0705,0706

* No.0705.Design HashSet
* No.0706.Design HashMap

Author: yanglbme

solution/0700-0799/0705.Design HashSet/README.md

@@ -50,7 +50,17 @@ myHashSet.contains(2); // 返回 False ，（已移除）</pre>
 
 <!-- 这里可写通用的实现逻辑 -->
 
-数组实现。
+**方法一：静态数组实现**
+
+直接创建一个大小为 $1000001$ 的数组，初始时数组中的每个元素都为 `false`，表示哈希集合中不存在该元素。
+
+往哈希集合添加元素时，将数组中对应位置的值置为 `true`；删除元素时，将数组中对应位置的值置为 `false`；当查询元素是否存在时，直接返回数组中对应位置的值即可。
+
+以上操作的时间复杂度均为 $O(1)$。
+
+**方法二：数组嵌套链表**
+
+我们也可以开辟一个大小为 `SIZE=1000` 的数组，数组的每个位置是一个链表。
 
 <!-- tabs:start -->
 
@@ -60,10 +70,8 @@ myHashSet.contains(2); // 返回 False ，（已移除）</pre>
 
 ```python
 class MyHashSet:
+
     def __init__(self):
-        """
-        Initialize your data structure here.
-        """
         self.data = [False] * 1000001
 
     def add(self, key: int) -> None:
@@ -73,12 +81,43 @@ class MyHashSet:
         self.data[key] = False
 
     def contains(self, key: int) -> bool:
-        """
-        Returns true if this set contains the specified element
-        """
         return self.data[key]
 
 
+# Your MyHashSet object will be instantiated and called as such:
+# obj = MyHashSet()
+# obj.add(key)
+# obj.remove(key)
+# param_3 = obj.contains(key)
+```
+
+```python
+class MyHashSet:
+
+    def __init__(self):
+        self.size = 1000
+        self.data = [[] for _ in range(self.size)]
+
+    def add(self, key: int) -> None:
+        if self.contains(key):
+            return
+        idx = self.hash(key)
+        self.data[idx].append(key)
+
+    def remove(self, key: int) -> None:
+        if not self.contains(key):
+            return
+        idx = self.hash(key)
+        self.data[idx].remove(key)
+
+    def contains(self, key: int) -> bool:
+        idx = self.hash(key)
+        return any(v == key for v in self.data[idx])
+
+    def hash(self, key) -> int:
+        return key % self.size
+
+
 # Your MyHashSet object will be instantiated and called as such:
 # obj = MyHashSet()
 # obj.add(key)
@@ -90,16 +129,12 @@ class MyHashSet:
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
--   可以一次性开辟一个大的数组，存放所有元素。
-
 ```java
 class MyHashSet {
+    private boolean[] data = new boolean[1000001];
 
-    private boolean[] data;
-
-    /** Initialize your data structure here. */
     public MyHashSet() {
-        data = new boolean[1000001];
+
     }
 
     public void add(int key) {
@@ -110,7 +145,6 @@ class MyHashSet {
         data[key] = false;
     }
 
-    /** Returns true if this set contains the specified element */
     public boolean contains(int key) {
         return data[key];
     }
@@ -125,46 +159,42 @@ class MyHashSet {
  */
 ```
 
--   也可以开辟一个大小为 `SIZE` 的数组，数组的每个位置是一个链表。
-
 ```java
 class MyHashSet {
-
     private static final int SIZE = 1000;
     private LinkedList[] data;
 
-    /** Initialize your data structure here. */
     public MyHashSet() {
         data = new LinkedList[SIZE];
-        Arrays.fill(data, new LinkedList<Integer>());
+        for (int i = 0; i < SIZE; ++i) {
+            data[i] = new LinkedList<Integer>();
+        }
     }
 
     public void add(int key) {
-        int index = hash(key);
-        Iterator<Integer> iterator = data[index].iterator();
-        while (iterator.hasNext()) {
-            Integer e = iterator.next();
-            if (e == key) return;
+        if (contains(key)) {
+            return;
         }
-        data[index].addFirst(key);
+        int idx = hash(key);
+        data[idx].addFirst(key);
     }
 
     public void remove(int key) {
-        int index = hash(key);
-        ListIterator<Integer> iterator = data[index].listIterator();
-        while (iterator.hasNext()) {
-            Integer e = iterator.next();
-            if (e == key) iterator.remove();
+        if (!contains(key)) {
+            return;
         }
+        int idx = hash(key);
+        data[idx].remove(Integer.valueOf(key));
     }
 
-    /** Returns true if this set contains the specified element */
     public boolean contains(int key) {
-        int index = hash(key);
-        Iterator<Integer> iterator = data[index].iterator();
-        while (iterator.hasNext()) {
-            Integer e = iterator.next();
-            if (e == key) return true;
+        int idx = hash(key);
+        Iterator<Integer> it = data[idx].iterator();
+        while (it.hasNext()) {
+            Integer e = it.next();
+            if (e == key) {
+                return true;
+            }
         }
         return false;
     }
@@ -183,6 +213,172 @@ class MyHashSet {
  */
 ```
 
+### **C++**
+
+```cpp
+class MyHashSet {
+public:
+    bool data[1000001];
+
+    MyHashSet() {
+        memset(data, false, sizeof data);
+    }
+
+    void add(int key) {
+        data[key] = true;
+    }
+
+    void remove(int key) {
+        data[key] = false;
+    }
+
+    bool contains(int key) {
+        return data[key];
+    }
+};
+
+/**
+ * Your MyHashSet object will be instantiated and called as such:
+ * MyHashSet* obj = new MyHashSet();
+ * obj->add(key);
+ * obj->remove(key);
+ * bool param_3 = obj->contains(key);
+ */
+```
+
+```cpp
+class MyHashSet {
+private:
+    int size = 1000;
+    vector<list<int>> data;
+
+public:
+    MyHashSet(): data(size) {
+
+    }
+
+    void add(int key) {
+        if (contains(key)) {
+            return;
+        }
+        int idx = hash(key);
+        data[idx].push_back(key);
+    }
+
+    void remove(int key) {
+        if (!contains(key)) {
+            return;
+        }
+        int idx = hash(key);
+        data[idx].remove(key);
+    }
+
+    bool contains(int key) {
+        int idx = hash(key);
+        for (auto it = data[idx].begin(); it != data[idx].end(); it++) {
+            if ((*it) == key) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    int hash(int key) {
+        return key % size;
+    }
+};
+
+/**
+ * Your MyHashSet object will be instantiated and called as such:
+ * MyHashSet* obj = new MyHashSet();
+ * obj->add(key);
+ * obj->remove(key);
+ * bool param_3 = obj->contains(key);
+ */
+```
+
+### **Go**
+
+```go
+type MyHashSet struct {
+	data []bool
+}
+
+func Constructor() MyHashSet {
+	data := make([]bool, 1000010)
+	return MyHashSet{data}
+}
+
+func (this *MyHashSet) Add(key int) {
+	this.data[key] = true
+}
+
+func (this *MyHashSet) Remove(key int) {
+	this.data[key] = false
+}
+
+func (this *MyHashSet) Contains(key int) bool {
+	return this.data[key]
+}
+
+/**
+ * Your MyHashSet object will be instantiated and called as such:
+ * obj := Constructor();
+ * obj.Add(key);
+ * obj.Remove(key);
+ * param_3 := obj.Contains(key);
+ */
+```
+
+```go
+type MyHashSet struct {
+	data []list.List
+}
+
+func Constructor() MyHashSet {
+	return MyHashSet{make([]list.List, 1000)}
+}
+
+func (this *MyHashSet) Add(key int) {
+	if this.Contains(key) {
+		return
+	}
+	idx := this.hash(key)
+	this.data[idx].PushBack(key)
+}
+
+func (this *MyHashSet) Remove(key int) {
+	idx := this.hash(key)
+	for e := this.data[idx].Front(); e != nil; e = e.Next() {
+		if e.Value.(int) == key {
+			this.data[idx].Remove(e)
+		}
+	}
+}
+
+func (this *MyHashSet) Contains(key int) bool {
+	idx := this.hash(key)
+	for e := this.data[idx].Front(); e != nil; e = e.Next() {
+		if e.Value.(int) == key {
+			return true
+		}
+	}
+	return false
+}
+
+func (this *MyHashSet) hash(key int) int {
+	return key % len(this.data)
+}
+
+/**
+ * Your MyHashSet object will be instantiated and called as such:
+ * obj := Constructor();
+ * obj.Add(key);
+ * obj.Remove(key);
+ * param_3 := obj.Contains(key);
+ */
+```
+
 ### **TypeScript**
 
 ```ts