Data-Structures on I'm Gilmar Soares

How to Build a Hashmap

Thu, 06 Mar 2025 17:54:50 -0300

This week, we’re diving into one of the most powerful and fundamental data structures in programming: the Hash Map, often called a Hash Table or Dictionary. Hash maps are vital in nearly every language for quickly storing and retrieving data as key-value pairs.

What’s a Hash Map, Really?

A Hash Map is an array-based structure that gives you near-instant access to a stored value. It achieves this speed by using a special hash function to convert the key (e.g., a person’s name) into an index (a number) in the underlying array.

Think of it like a coat check:

The key is the unique ticket number you receive.

The hash function is the attendant who instantly knows which hook (the index) your coat is on.

The value is your coat itself.

For this simple example, we’ll use a fixed-size array of 10 slots. Important: To keep the code simple, this implementation does not handle collisions—a scenario where two different keys hash to the same index.

Python’s Built-in Hash Map: The dict

Before we build our own, let’s look at Python’s highly optimized, native implementation: the dict. Python

Create an empty dictionary

user_profile = {}

Store key-value pairs

user_profile["username"] = "coder_x"
user_profile["status"] = "online"

Retrieve a value instantly using its key

print(user_profile["username"]) # Output: coder_x

The final structure

print(user_profile) # Output: {'username': 'coder_x', 'status': 'online'}

Building a Custom HashMap Class

Now, let’s implement the core logic ourselves. Our HashMap will clearly show how keys are converted to array indices for storage and retrieval:

class HashMap:
    def __init__(self, size):
        self.size = size
        # Initialize the map: a list of 'None' values
        self.map = [None] * self.size

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

    def set(self, key, value):
        index = self._hash(key)
        self.map[index] = value

    def get(self, key):
        index = self._hash(key)
        return self.map[index]

    def __str__(self):
        return str(self.map)

Practical Example and Indexing

Let’s see our custom HashMap in action and observe the indices it generates: Python

1. Initialize the hash map with 10 slots

contact_list = HashMap(10)

2. Store entries (Note: the hash index is calculated internally)

Key: “Alice” -> hash index: 3

contact_list.set("Alice", "555-0101")

Key: “Bob” -> hash index: 6

contact_list.set("Bob", "555-0202")

Key: “Charlie” -> hash index: 7

contact_list.set("Charlie", "555-0303")

3. Retrieve values using the original keys

print(f"Alice's Number: {contact_list.get('Alice')}")    # Output: 555-0101
print(f"Bob's Number: {contact_list.get('Bob')}")      # Output: 555-0202

4. View the underlying array after insertions

print("\n--- Map Array State ---")
print(str(contact_list))

Output (Indices 0-9):

[None, None, None, '555-0101', None, None, '555-0202', '555-0303', None, None]

This simplified model demonstrates the core principle: using a hash function to achieve fast O(1) (constant time) lookups by jumping directly to the correct array slot. Real-world hash maps add complexity to handle growth and collisions, but the foundational concept remains this efficient indexing strategy!

I hope this walkthrough has given you a solid understanding of how a Hash Map works at its core! While our example was simple, it demonstrates the efficient hashing and indexing that makes this data structure so powerful. Got a question or need clarification on collisions or resizing? Don’t hesitate to reach out in the comments below! Happy coding!

Selection Sort

Thu, 05 Dec 2024 18:46:28 -0300

Continuing my study of algorithms, I can now explain the selection sort algorithm to you.

Selection sort is a simple algorithm. It works by finding the smallest element in an array, adding it to a new array, and removing it from the original array. This process is repeated until the original array is empty. Once the original array is empty, the new array will contain the elements in sorted order.

In this example, I am not focusing on performance but rather on the simplicity of the algorithm.

Here is the array we will use for our example:

arr := []int{100, 5, 3, 6, 2, 10}

For the next step I create the function that receive this arr and return the sorted array:

func orderIntArray(arr []int) []int {
	var result []int
	var min int

	for len(arr) > 0 {
		min = getSmallerItem(arr)
		result = append(result, arr[min])
		arr = remove(arr, min)
	}

	return result
}

The getSmallerItem function is responsible to get the index of the smallest element in the array:

func getSmallerItem(arr []int) int {
	var min int = arr[0]
	var pos int

	for i := 1; i < len(arr); i++ {
		if arr[i] < min {
			min = arr[i]
			pos = i
		}
	}
	return pos
}

The getSmallerItem function compare the element in the array with the min variable, if the element is smaller than the min variable, the min variable will be updated with the element value and the pos variable will be updated with the index of the element. When the loop finish, the pos variable will be returned.

The remove function is responsible to remove the element from the array:

func remove(s []int, i int) []int {
	s[i] = s[len(s)-1]
	return s[:len(s)-1]
}

The remove function receive the array and the index of the element that will be removed.

Now we can test the function:

func main() {
	arr := []int{100, 5, 3, 6, 2, 10}
	result := orderIntArray(arr)
	fmt.Println(result) // return is [2 3 5 6 10 100]
}

This algorithm is not efficient, but is a good example to understand the selection sort algorithm.

I hope you enjoy this post, see you in the next one!

Explaining Binary Search in a Simple Way

Thu, 21 Nov 2024 16:15:51 -0300

Today I try to explain binary search in a simple way. Binary search is a search algorithm that finds the position of a target value within a sorted array. Sorted array is an important point here.

To explain binary search, we need a array to exemplify.

arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

In this array, we have 10 elements, from 1 to 10. Binary search works by comparing the target value to the middle element of the array.

For example, if we want to find the number 5 in the array, we start by comparing 5 to the middle element of the array, which is 6.

Next step is to compare 5 to 6. If 5 is less than 6, we can discard the right half of the array. The new array is now:

arr := []int{1, 2, 3, 4, 5}

Now we repeat the process, comparing 5 to the middle element of the new array, which is 3.

Next step is to compare 5 to 3. If 5 is greater than 3, we can discard the left half of the array. The new array is now:

arr := []int{4, 5}

Now we repeat the process, comparing 5 to the middle element of the new array, which is 5. And we found the number 5 in the array.

In this simple example we found the number 5 in 3 steps. This is my simple explanation of binary search.

Now I can implement the binary search algorithm in Go.

package main

func search(arr []int, searchItem int) int {
	minus := 0
	max := len(arr) - 1

	for minus <= max {
		middle := (minus + max) / 2
		tryFind := arr[middle]
		if tryFind == searchItem {
			return middle
		}
		if tryFind > searchItem {
			max = middle - 1
		} else {
			minus = middle + 1
		}
	}

	return -1
}

Now I can use the search function to find the number 5 in the array.

func main() {
	arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	searchItem := 80
	pos := search(arr, searchItem)
	var message string
	message = fmt.Sprintf("Find item %d in %d position", searchItem, searchItem)
	if pos == -1 {
		message = fmt.Sprintf("Item %d not found", searchItem)
	}
	fmt.Println(message)
}

This is the output of the program:

Item 80 not found

This algorithm reminds me of a phrase I often hear: ‘divide and conquer! I hope this post, along with the others, helps you in your studies and, more importantly, helps you understand that the best path is always through deep knowledge!

See you next time! Thanks for reading my blog. Hugs!