Breaking News: Grepper is joining You.com. Read the official announcement!

Big-O for operations in a Hashmap

isuro answered on January 23, 2023 Popularity 6/10 Helpfulness 1/10

answer Big-O for operations in a Hashmap

Big-O for operations in a Hashmap

Comment

here's an example of a simple hash map implementation in Python:
class HashMap:
    def __init__(self, size=10):
        self.size = size
        self.data = [[] for _ in range(self.size)]

    def _hash(self, key):
        return hash(key) % self.size

    def insert(self, key, value):
        index = self._hash(key)
        key_exists = False
        bucket = self.data[index]
        for i, kv in enumerate(bucket):
            k, v = kv
            if key == k:
                key_exists = True
                break
        if key_exists:
            bucket[i] = ((key, value))
        else:
            bucket.append((key, value))

    def search(self, key):
        index = self._hash(key)
        bucket = self.data[index]
        for kv in bucket:
            k, v = kv
            if key == k:
                return v
        return None

    def delete(self, key):
        index = self._hash(key)
        bucket = self.data[index]
        for i, kv in enumerate(bucket):
            k, v = kv
            if key == k:
                del bucket[i]
                break

In this implementation, we use the built-in Python hash function to
map keys to indices in an underlying array (self.data) of a fixed size 
(self.size). Each index in the array represents a "bucket" where key-value
pairs with the same hash are stored.

Insert, search and delete operations all have an average time complexity 
of O(1) because we are only ever looking in one bucket of the array which 
is the one that the key maps to. However, the worst case time complexity 
for these operations is O(n) where n is the number of key-value pairs in 
the bucket, if the hash function results in a high degree of collisions.

Note that this is a basic example, real world hashmap implementation uses 
more advanced technique like chaining and rehashing to handle the collisions.

Popularity 6/10 Helpfulness 1/10 Language python

Source: Grepper

Tags: big-o hashmap operations python

Link to this answer
Share Copy Link

Contributed on Jan 23 2023

isuro

0 Answers Avg Quality 2/10

Big-O for operations in a Hashmap

Contents

More Related Answers

Big-O for operations in a Hashmap

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.