Introducción

• Un mapa hash, también conocido como tabla hash, es una estructura de datos que implementa un tipo de datos abstracto de matriz asociativa, una estructura que puede asignar claves a valores.

• Utiliza una función hash para calcular un índice en una matriz de depósitos o ranuras, a partir de los cuales se puede encontrar el valor deseado.

• La principal ventaja de un Hash Map es su eficiencia. Operaciones como insertar un nuevo par clave-valor, eliminar un par clave-valor y buscar un valor dada una clave son todas muy rápidas y, a menudo, toman un tiempo constante en promedio.

Implementación de un mapa hash simple en JavaScript

let hashMap = {};
hashMap['key1'] = 'value1';
hashMap['key2'] = 'value2';
console.log(hashMap['key1']); // Outputs: value1

Manejo de colisiones

• El manejo de colisiones es un aspecto importante de la implementación de un Hash Map. Se produce una colisión cuando dos claves diferentes producen el mismo hash. Existen varias estrategias para manejar las colisiones, pero las dos más comunes son encadenamiento separado y sondeo lineal.

Encadenamiento separado: en el encadenamiento separado, cada ranura en la matriz de la tabla hash contiene una lista vinculada (u otra estructura de datos que puede contener varios elementos). Cuando ocurre una colisión, el nuevo par clave-valor se agrega al final de la lista vinculada en el índice correspondiente.

Aquí hay una implementación simple de un mapa Hash usando encadenamiento separado en JavaScript:

class HashMap {
  constructor() {
    this.table = new Array(100).fill(null).map(() => []);
  }

  put(key, value) {
    const index = this.hash(key);
    const chain = this.table[index];
    const existingPair = chain.find(([existingKey]) => existingKey === key);

    if (existingPair) {
      existingPair[1] = value;
    } else {
      chain.push([key, value]);
    }
  }

  get(key) {
    const index = this.hash(key);
    const chain = this.table[index];
    const pair = chain.find(([existingKey]) => existingKey === key);

    if (pair) {
      return pair[1];
    }

    return null;
  }

  hash(key) {
    let hash = 0;
    for (let i = 0; i 



Sondeo lineal: en el sondeo lineal, cuando ocurre una colisión, el mapa hash verifica la siguiente ranura en la matriz (y continúa con la siguiente si también está llena, y así sucesivamente) hasta que encuentra una ranura vacía donde puede almacenar el nuevo par clave-valor.

Aquí hay una implementación simple de un Hash Map usando sondeo lineal en JavaScript:


class HashMap {
  constructor() {
    this.table = new Array(100).fill(null);
  }

  put(key, value) {
    let index = this.hash(key);
    while (this.table[index] !== null) {
      index = (index   1) % this.table.length;
    }
    this.table[index] = [key, value];
  }

  get(key) {
    let index = this.hash(key);
    while (this.table[index] !== null) {
      if (this.table[index][0] === key) {
        return this.table[index][1];
      }
      index = (index   1) % this.table.length;
    }
    return null;
  }

  hash(key) {
    let hash = 0;
    for (let i = 0; i 



En ambos ejemplos, el método hash es una función hash simple que convierte la clave en un número entero que se utiliza como índice en la matriz. En un escenario del mundo real, probablemente usarías una función hash más compleja para reducir la probabilidad de colisiones.