




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.
1using System;
2using System.Collections.Generic;
3
4public class MyHashMap {
5
6    private class Pair {
7        public int Key;
8        public int Value;
9        public Pair(int key, int value) {
10            Key = key;
11            Value = value;
12        }
13    }
14
15    private const int size = 1000;
16    private List<Pair>[] map;
17
18    public MyHashMap() {
19        map = new List<Pair>[size];
20        for (int i = 0; i < size; i++) {
21            map[i] = new List<Pair>();
22        }
23    }
24
25    private int Hash(int key) {
26        return key % size;
27    }
28
29    public void Put(int key, int value) {
30        int hashKey = Hash(key);
31        foreach (Pair pair in map[hashKey]) {
32            if (pair.Key == key) {
33                pair.Value = value;
34                return;
35            }
36        }
37        map[hashKey].Add(new Pair(key, value));
38    }
39
40    public int Get(int key) {
41        int hashKey = Hash(key);
42        foreach (Pair pair in map[hashKey]) {
43            if (pair.Key == key) {
44                return pair.Value;
45            }
46        }
47        return -1;
48    }
49
50    public void Remove(int key) {
51        int hashKey = Hash(key);
52        Pair toRemove = null;
53        foreach (Pair pair in map[hashKey]) {
54            if (pair.Key == key) {
55                toRemove = pair;
56                break;
57            }
58        }
59        if (toRemove != null) {
60            map[hashKey].Remove(toRemove);
61        }
62    }
63}The C# solution uses arrays of lists to implement the hash map. Each list handles collisions for a specific index of the map.
Pair class for storing key-value data is used.Put method looks for a key in its bucket and updates the value or adds a new pair if the key wasn't found.Get retrieves values by key, returning -1 if the key doesn't exist.Remove deletes the key-value pair.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.
1#
This C solution uses open addressing with double hashing. The second hash function provides an alternative probe sequence in case of collisions.
primaryHash and secondaryHash calculate indices.myHashMapPut uses the hashes to determine entry positions.myHashMapGet uses double hashing to locate the desired key.myHashMapRemove marks an entry as unoccupied upon deletion.