Fala galera da programação, tudo beleza? Você já ouviu falar sobre Hashmap? Venha descubrir o poder dos Hashmaps. Vamos fazer uma abordagem completa sobre esta estrutura de dados essencial. Aprenda sobre funções de hash, eficiência e aplicações práticas.
Na ciência da computação, um dos desafios mais comuns é a organização e recuperação eficiente de dados. Um dos conceitos mais poderosos para resolver esse problema é o hashmap, também conhecido como mapa de hash ou tabela de dispersão. Neste artigo, exploraremos profundamente o funcionamento, a aplicação e os benefícios dos hashmaps, com exemplos práticos para ilustrar seu uso.
Um hashmap é uma estrutura de dados que mapeia chaves para valores. Ele opera com base em uma função de hash, que converte a chave em um índice na estrutura de dados. Este índice é então utilizado para armazenar e recuperar o valor associado àquela chave. A principal vantagem de um hashmap é a sua capacidade de realizar operações de busca, inserção e remoção em tempo constante, em média, quando a função de hash distribui uniformemente os valores na estrutura de dados.
O funcionamento básico de um hashmap pode ser dividido em algumas etapas simples:
Os hashmaps são amplamente utilizados em uma variedade de contextos de programação, incluindo:
'''
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
'''
class Hashmap:
def __init__(self):
self.size = 10
self.map = [None] * self.size
def get_hash(self, key):
return hash(key) % self.size
def add(self, key, value):
key_hash = self.get_hash(key)
self.map[key_hash] = value
def get(self, key):
key_hash = self.get_hash(key)
return self.map[key_hash]
# Uso do Hashmap
h = Hashmap()
h.add('a', 100)
h.add('b', 200)
print(h.get('a')) # Saída: 100
print(h.get('b')) # Saída: 200
Imagine um hashmap como uma grande caixa cheia de pequenas caixas numeradas. Cada vez que você coloca algo dentro da grande caixa, você dá a esse algo um número especial, chamado de “hash”. Esse número é como um endereço para encontrar a pequena caixa correspondente na grande caixa.
No exemplo em Python:
map) com espaço para 10 pequenas caixas dentro dela.get_hash) para calcular o número (o hash) que vai identificar a pequena caixa onde vamos guardar esse algo.Em resumo, o hashmap é como uma grande caixa com muitas pequenas caixas numeradas. Você coloca coisas dentro usando números especiais (hashes) e depois pode encontrá-las rapidamente usando esses números especiais. É uma maneira eficiente de guardar e encontrar coisas!
'''
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
'''
def count_occurrences(arr):
occurrence_map = {}
for item in arr:
if item in occurrence_map:
occurrence_map[item] += 1
else:
occurrence_map[item] = 1
return occurrence_map
# Uso do Hashmap para contar ocorrências
arr = [1, 2, 3, 1, 2, 1, 3, 4, 5]
print(count_occurrences(arr)) # Saída: {1: 3, 2: 2, 3: 2, 4: 1, 5: 1}
Explicação
Imagine que você tem uma caixa cheia de números escritos em pequenos pedaços de papel. Você quer saber quantas vezes cada número aparece nessa caixa. Aqui está o que acontece:
count_occurrences:
occurrence_map) para registrar quantas vezes cada número aparece.[1, 2, 3, 1, 2, 1, 3, 4, 5]).Então, a função count_occurrences é como um assistente que conta quantas vezes cada número aparece em uma caixa cheia de números. É útil quando você precisa saber com que frequência certos números aparecem em uma lista.
Ou seja, para este nosso exemplo:
Número 1: Apareceu 3 Vezes;
Número 2: Apareceu 2 Vezes;
Número 3: Apareceu 2 Vezes;
Número 4: Apareceu 1 Vez;
Número 5: Apareceu 1 Vez.
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
htttp://giovanidacruz.com.br
*******************************************************************************/
package main
import (
"fmt"
"hash/fnv"
)
type Hashmap struct {
size int
mapData map[int]interface{}
}
func NewHashmap(size int) *Hashmap {
return &Hashmap{
size: size,
mapData: make(map[int]interface{}),
}
}
func (h *Hashmap) getHash(key string) int {
hfunc := fnv.New32a()
hfunc.Write([]byte(key))
return int(hfunc.Sum32()) % h.size
}
func (h *Hashmap) Add(key string, value interface{}) {
keyHash := h.getHash(key)
h.mapData[keyHash] = value
}
func (h *Hashmap) Get(key string) interface{} {
keyHash := h.getHash(key)
return h.mapData[keyHash]
}
func main() {
h := NewHashmap(10)
h.Add("a", 1)
h.Add("b", 2)
fmt.Println(h.Get("a")) // Saída: 1
fmt.Println(h.Get("b")) // Saída: 2
}
Explicação:
Hashmap, que contém dois campos: size, que é o tamanho do hashmap, e mapData, que é o mapa real onde os dados serão armazenados.NewHashmap cria uma nova instância de Hashmap com um tamanho especificado. Inicializa o mapa interno (mapData) com a função make.getHash calcula o hash de uma chave. Em Go, usamos o tamanho da chave (comprimento de key) e o dividimos pelo tamanho do hashmap (size).Add adiciona um par chave-valor ao hashmap. Calcula o hash da chave e usa esse valor para acessar o mapa interno e atribuir o valor correspondente.Get recupera um valor associado a uma chave. Ele calcula o hash da chave e usa esse valor para acessar o mapa interno e retornar o valor correspondente.main, criamos uma nova instância de Hashmap, adicionamos pares chave-valor e depois os recuperamos usando a função Get. Os valores recuperados são então impressos na tela.Este exemplo demonstra como usar um hashmap em Go para armazenar e recuperar dados por meio de chaves.
package main
import "fmt"
func CountOccurrences(arr []int) map[int]int {
occurrenceMap := make(map[int]int)
for _, item := range arr {
occurrenceMap[item]++
}
return occurrenceMap
}
func main() {
arr := []int{1, 2, 3, 1, 2, 1, 3, 4, 5}
fmt.Println(CountOccurrences(arr)) // Output: map[1:3 2:2 3:2 4:1 5:1]
}
Explicação:
CountOccurrences recebe uma lista de números (arr) e retorna um mapa que conta quantas vezes cada número aparece na lista.CountOccurrences, criamos um mapa vazio chamado occurrenceMap para armazenar as ocorrências dos números.main, criamos uma lista de números e chamamos a função CountOccurrences passando essa lista como argumento. A função conta as ocorrências e imprime o resultado.Este exemplo mostra como usar um hashmap em Go para contar quantas vezes cada número aparece em uma lista de números.
Os hashmaps são uma ferramenta poderosa e versátil em ciência da computação, oferecendo uma maneira eficiente de organizar e acessar dados. Com seu desempenho rápido e flexibilidade, os hashmaps são uma escolha popular para uma variedade de problemas de programação. Ao compreender os princípios subjacentes dos hashmaps e suas aplicações práticas, os desenvolvedores podem aproveitar ao máximo essa estrutura de dados em seus projetos.
Beleza pessoal? Espero que possa ajudar!
Dúvidas ou sugestões? Deixe o seu comentário!
Um abraço e até o próximo post. Valeu!
#Hashmap
#EstruturasDeDados
#Programação
#LinkedInLearning
#GiovaniDaCruz
Está gostando do conteúdo?
Considere pagar um cafezinho para nossa equipe!
