Sponsored
Sponsored
This method employs an array of linked lists (chaining) to handle collisions. Each index represents a hash code, and if multiple keys hash to the same index, we store them in a linked list at that index. This helps us efficiently manage key collisions.
Time Complexity: For each operation (put, get, remove), it is O(n) in the worst case, where n is the number of keys stored at a particular index.
Space Complexity: O(N) where N is the number of distinct keys inserted into the hash map.
1#include <vector>
2#include <list>
3using namespace std;
4
5class MyHashMap {
6private:
7 static const int size = 1000;
8 vector<list<pair<int, int>>> map;
9
10 int hash(int key) {
11 return key % size;
12 }
13
14public:
15 MyHashMap() {
16 map.resize(size);
17 }
18
19 void put(int key, int value) {
20 int idx = hash(key);
21 for (auto &it : map[idx]) {
22 if (it.first == key) {
23 it.second = value;
24 return;
25 }
26 }
27 map[idx].emplace_back(key, value);
28 }
29
30 int get(int key) {
31 int idx = hash(key);
32 for (const auto &it : map[idx]) {
33 if (it.first == key) {
34 return it.second;
35 }
36 }
37 return -1;
38 }
39
40 void remove(int key) {
41 int idx = hash(key);
42 map[idx].remove_if([key](const pair<int, int> &it) { return it.first == key; });
43 }
44};This C++ solution uses a vector of linked lists to implement a hash map with separate chaining. The linked lists are implemented as lists of key-value pairs (using the STL list).
hash function computes the index for a given key.put, we update the value if the key exists; otherwise, we insert it.get, we check each element at the computed index for the desired key.remove, we utilize remove_if to delete the key-value pair if found.Double hashing avoids the clustering problem by calculating two hash functions. If a collision occurs, a second hash determines the step size for probing.
Time Complexity: O(1) on average for put, get, and remove due to effective hashing; O(n) in worst-case.
Space Complexity: O(N) for storing entries with keys and values.
1class
In JavaScript's setup, judicious double hashing governs open addressing policy, augmenting efficiency usually diminished by collision instances.