Design HashMap

Published at24 Jul 2026

Like0

Design a hash map without using any built-in hash table libraries. Implement the MyHashMap class with three methods: put(key, value) inserts or updates a key-value pair, get(key) returns the value or -1 if not found, and remove(key) deletes the key if it exists.

A hash map is a fundamental data structure that maps keys to values using a hash function. The core idea is to use an array of buckets where each bucket stores entries that share the same hash index. The hash function key % capacity determines which bucket a key belongs to. Collisions (multiple keys mapping to the same bucket) are handled with chaining — each bucket is a linked list or dynamic array of entries.

This implementation uses an array of lists with an initial capacity of 1000. Each bucket stores a list of [key, value] pairs. For put, compute the hash index, scan the bucket for the key, and either update or append. For get, compute the hash index and scan for the key. For remove, compute the hash index, find the key in the bucket, and delete the entry.

Edge cases include putting a key that already exists (overwrite), getting a key that was never inserted (return -1), removing a key that does not exist (do nothing), and handling negative keys (use absolute value in the hash function).

Example Input & Output

Example 1

Input

put(0,0), get(0)

Output

Explanation

Key 0 is stored correctly.

Example 2

Input

put(1,1), put(2,2), get(1), get(3), put(2,1), get(2), remove(2), get(2)

Output

1,-1,1,-1

Explanation

Standard sequence of operations.

Example 3

Input

put(-5,10), get(-5)

Output

Explanation

Negative keys work via abs hash.

Example 4

Input

put(1000,1), put(0,2), get(1000), get(0)

Output

1,2

Explanation

Keys that may collide in same bucket.

Example 5

Input

get(99)

Output

-1

Explanation

Getting non-existent key returns -1.

Algorithm Flow

Recommendation Algorithm Flow for Design HashMap

Solution Approach

Use an array of buckets. Hash function: abs(key) % capacity. Each bucket stores key-value pairs. Handle collisions via chaining with lists.

function solution() {
  var cap = 1000;
  var buckets = new Array(cap);
  for (var i = 0; i < cap; i++) buckets[i] = [];
  return {
    put: function(key, value) {
      var h = key % cap;
      if (h < 0) h = -h;
      for (var i = 0; i < buckets[h].length; i++) {
        if (buckets[h][i][0] === key) { buckets[h][i][1] = value; return; }
      }
      buckets[h].push([key, value]);
    },
    get: function(key) {
      var h = key % cap;
      if (h < 0) h = -h;
      for (var i = 0; i < buckets[h].length; i++) {
        if (buckets[h][i][0] === key) return buckets[h][i][1];
      }
      return -1;
    },
    remove: function(key) {
      var h = key % cap;
      if (h < 0) h = -h;
      for (var i = 0; i < buckets[h].length; i++) {
        if (buckets[h][i][0] === key) { buckets[h].splice(i, 1); return; }
      }
    }
  };
}

Time O(n/k) average per operation, Space O(n).

Best Answers
These are the verified best solutions for this Challenge. You can use them as a reference to improve your solution.

java

import java.util.*;
class MyHashMap {
    private int cap = 1000;
    private List<int[]>[] buckets;
    public MyHashMap() {
        buckets = new List[cap];
        for (int i = 0; i < cap; i++) buckets[i] = new ArrayList<>();
    }
    private int hash(int key) { return Math.abs(key) % cap; }
    public void put(int key, int value) {
        int h = hash(key);
        for (int[] e : buckets[h]) {
            if (e[0] == key) { e[1] = value; return; }
        }
        buckets[h].add(new int[]{key, value});
    }
    public int get(int key) {
        int h = hash(key);
        for (int[] e : buckets[h]) {
            if (e[0] == key) return e[1];
        }
        return -1;
    }
    public void remove(int key) {
        int h = hash(key);
        var it = buckets[h].iterator();
        while (it.hasNext()) {
            if (it.next()[0] == key) { it.remove(); return; }
        }
    }
}

javascript

function solution() {
  var cap = 1000;
  var buckets = new Array(cap);
  for (var i = 0; i < cap; i++) buckets[i] = [];
  return {
    put: function(key, value) {
      var h = key % cap;
      if (h < 0) h = -h;
      for (var i = 0; i < buckets[h].length; i++) {
        if (buckets[h][i][0] === key) { buckets[h][i][1] = value; return; }
      }
      buckets[h].push([key, value]);
    },
    get: function(key) {
      var h = key % cap;
      if (h < 0) h = -h;
      for (var i = 0; i < buckets[h].length; i++) {
        if (buckets[h][i][0] === key) return buckets[h][i][1];
      }
      return -1;
    },
    remove: function(key) {
      var h = key % cap;
      if (h < 0) h = -h;
      for (var i = 0; i < buckets[h].length; i++) {
        if (buckets[h][i][0] === key) { buckets[h].splice(i, 1); return; }
      }
    }
  };
}

php

<?php
class MyHashMap {
    private $cap = 1000;
    private $buckets;
    function __construct() {
        $this->buckets = array_fill(0, $this->cap, []);
    }
    function put($key, $value) {
        $h = abs($key) % $this->cap;
        foreach ($this->buckets[$h] as &$e) {
            if ($e[0] === $key) { $e[1] = $value; return; }
        }
        $this->buckets[$h][] = [$key, $value];
    }
    function get($key) {
        $h = abs($key) % $this->cap;
        foreach ($this->buckets[$h] as $e) {
            if ($e[0] === $key) return $e[1];
        }
        return -1;
    }
    function remove($key) {
        $h = abs($key) % $this->cap;
        foreach ($this->buckets[$h] as $i => $e) {
            if ($e[0] === $key) { array_splice($this->buckets[$h], $i, 1); return; }
        }
    }
}

python

class MyHashMap:
    def __init__(self):
        self.cap = 1000
        self.buckets = [[] for _ in range(self.cap)]
    def _hash(self, key):
        return abs(key) % self.cap
    def put(self, key, value):
        h = self._hash(key)
        for i, (k, v) in enumerate(self.buckets[h]):
            if k == key:
                self.buckets[h][i] = [key, value]
                return
        self.buckets[h].append([key, value])
    def get(self, key):
        h = self._hash(key)
        for k, v in self.buckets[h]:
            if k == key:
                return v
        return -1
    def remove(self, key):
        h = self._hash(key)
        for i, (k, v) in enumerate(self.buckets[h]):
            if k == key:
                self.buckets[h].pop(i)
                return

rust

struct MyHashMap {
    cap: usize,
    buckets: Vec<Vec<(i32, i32)>>,
}
impl MyHashMap {
    fn new() -> Self {
        let cap = 1000;
        let mut buckets = Vec::with_capacity(cap);
        for _ in 0..cap { buckets.push(vec![]); }
        MyHashMap { cap, buckets }
    }
    fn put(&mut self, key: i32, value: i32) {
        let h = (key % self.cap as i32).abs() as usize;
        for e in self.buckets[h].iter_mut() {
            if e.0 == key { e.1 = value; return; }
        }
        self.buckets[h].push((key, value));
    }
    fn get(&self, key: i32) -> i32 {
        let h = (key % self.cap as i32).abs() as usize;
        for &(k, v) in &self.buckets[h] {
            if k == key { return v; }
        }
        -1
    }
    fn remove(&mut self, key: i32) {
        let h = (key % self.cap as i32).abs() as usize;
        self.buckets[h].retain(|&(k, _)| k != key);
    }
}

typescript

function solution(): any {
    var cap = 1000;
    var buckets: any = new Array(cap);
    for (var i = 0; i < cap; i++) buckets[i] = [];
    return {
        put: function(key: number, value: number): void {
            var h = key % cap;
            if (h < 0) h = -h;
            for (var i = 0; i < buckets[h].length; i++) {
                if (buckets[h][i][0] === key) { buckets[h][i][1] = value; return; }
            }
            buckets[h].push([key, value]);
        },
        get: function(key: number): number {
            var h = key % cap;
            if (h < 0) h = -h;
            for (var i = 0; i < buckets[h].length; i++) {
                if (buckets[h][i][0] === key) return buckets[h][i][1];
            }
            return -1;
        },
        remove: function(key: number): void {
            var h = key % cap;
            if (h < 0) h = -h;
            for (var i = 0; i < buckets[h].length; i++) {
                if (buckets[h][i][0] === key) { buckets[h].splice(i, 1); return; }
            }
        }
    };
}

Related Hash Table Challenges

Comments (0)

Join the Discussion

Share your thoughts, ask questions, or help others with this Challenge.

Design HashMap

Example Input & Output

Algorithm Flow

Solution Approach

Best AnswersThese are the verified best solutions for this Challenge. You can use them as a reference to improve your solution.

Solutions Coming Soon

Related Hash Table Challenges

Duplicate Indices Map

Contains Duplicate

Valid Anagram

Ransom Note

Two Sum Indices

Majority Element

Comments (0)

Join the Discussion

Best Answers
These are the verified best solutions for this Challenge. You can use them as a reference to improve your solution.