Playground: implementa el metodo Delete

Clase 13 de 29 • Curso de Estructuras de Datos con JavaScript

Limbert Lino Mattos

student•

Mi solución No retorno undefined ya que por defecto este se retorna si no halla el dato. El código esta comentado para mejor entendimiento de lo que hace.

  delete(key) {
    //* obtengo el hash del address
    const address = this.hashMethod(key)
    //* Obtengo el bucket donde debo buscar el espacio a eliminar
    const currentBucket = this.data[address]

    if (currentBucket) {
      //* recorriendo el espacio
      for (let i = 0; i < currentBucket.length; i++) {
        if (currentBucket[i][0] === key) {
          //* guardo el espacio para retornarlo luego
          let deletedSpace = currentBucket[i]
          //* elimino el espacio
          delete currentBucket[i]
          //* elimino el espacio vacio para que los demas espacios recorran
          currentBucket.splice(i, 1)
          return deletedSpace
        }
      }
    }
  }

Libian María Hernández Gil

student•

Muchas gracias, esos comentarios ayudan bastante... Me faltaba usar el método splice ... un millón.

Oscar Fernando López Lara

student•

Creo que ahi solo necesitas borrar ese array con splice, no es necesario el delete

Andres Eduardo Maneiro Antunez

student•

Me costó pero aquí aporto mi solución,

import { HashTable } from "./hashTable";

export class Solution extends HashTable {
  constructor(size) {
    super()
    this.data = new Array(size);
  }

  delete(key){
    // Tu código aquí 👈
    const address = this.hashMethod(key);
    const currentBucket = this.data[address];
    let itemDeleted
    if (currentBucket) {
      for (let i = 0; i < currentBucket.length; i++) {
        if (currentBucket[i][0] === key) {
          const index = i
          itemDeleted = currentBucket[i]
          if (currentBucket.length > 1) {
            for (let i = index; i < currentBucket.length - 1; i++) {
              this.data[address][0] = this.data[address][i + 1];
            }
            delete this.data[address][currentBucket.length - 1]
            console.log("Se ha eliminado el elemento");
            return itemDeleted
          } else {
            delete this.data[address];
            console.log("Se ha liberado el Address");
            return itemDeleted
          }
        }
      }
    }
    console.log("No se encontro ningun elemento a borrar");
    return undefined
  }
}

Alan Saldívar

student•

No es el tema de la clase pero hay que tener cuidado con el doble for ya que puede terminar siendo un algoritmo exponencial.

Jorge Barron

student•

les dejo una solución no tan compleja 😁 * * * * * * * * * *

delete(key) {
    const address = this.hashMethod(key)
    const bucket = this.data[address]
    // bucket data sample
    // [ [ 'Diego', 1990 ], [ 'Mariana', 2000 ] ]
    if (bucket) {
      // we search the index position for the bucket item that contains the incoming key
      const keyIndex = bucket.findIndex(([buckeItemtKey]) => buckeItemtKey === key)
      // if te item was found we delete the item using the splice method
      if (keyIndex !== -1) {
        return this.data[address].splice(keyIndex, 1)[0]
      }
    }
  }

Daniel Andres Rojas Paredes

student•

¿que diferencia hay entre eliminar una posicion de un arreglo con el metodo splice y la palabra reservada delete? mi codigo no paso con la ultima pruva y me di cuenta que esa era la diferencia entre mi codigo y la respuesta, hice una pequeña pruva en el navegador creando un arreglo y elimindando una posicion con delete a ver si era que quedava algun remanente de la posicion como un nan o un undefine, cuando volvi a imprimir el arreglo, aparecia inicialmente la palabra empty en el lugar donde elimine una posicion, sin embargo al inspeccionar el arreglo ya no aparecia nada y me decia que el arreglo era de 6 posiciones una menos que antes de usasr delete. asi que no habia remanente

MIguel Oviedo

student•

Al parecer delete no librera el espacio en memoria, pero con splice si. Por eso cuando lo eliminaste con delete, efectivamente se eliminó pero quedo el espacio en memoria con un valor Empy

Maided Guadalupe Hernández Ponce

student•

Mi solucion👀:

delete(key) {
    const address = this.hashMethod(key)
    const currentBucket = this.data[address]
    if (currentBucket) {
      for (let i = 0; i < currentBucket.length; i++) {
        if (currentBucket[i][0] === key) {
          if (currentBucket.length > 1) {
            const itemDeleted = currentBucket[i]
            for (let o = 0; o < currentBucket.length; o++) {
              // el primer elemento será igual al que le sigue al primero
              currentBucket[o] = currentBucket[o + 1]
            }
            delete currentBucket[currentBucket.length - 1]
            currentBucket.length--
            return itemDeleted
          } else {
            delete this.data[address]
            return currentBucket[i]
          }
        }
      }
    }
    return undefined
  }

Fernando Orozco Velasquez

student•

Esta es mi solución para este reto 💚

Acá pueden probar el código:

delete(key){
    const address = this.hashMethod(key);
    const currentBucket = this.data[address];
    if(currentBucket) {
      for (let i = 0; i < currentBucket.length; i++) {
        if(currentBucket[i][0] === key) {
          const deletedItem = this.data[address][i]
          this.data[address].splice(i, 1);
          return deletedItem;
        }
      }
    }
    return undefined
  }

Franklin Steven Fontalvo Valera

student•

Estuve viendo el curso de complejidad algorítmica, así que me esforcé por hacer sin usar dos ciclos :D

    delete(key) {
        const address = this.hashMethod(key);
        const currentBucket = this.data[address];

        if (currentBucket) {
            for (let i = 0; i < currentBucket.length; i++) {
                let backup = [];
                var elementForReturn;
                if (currentBucket[i][0] === key) {
                    elementForReturn = [...this.data[address][i]];
                    delete this.data[address][i];
                } else {
                    if (true) {
                        backup.push(currentBucket[i]);
                    }
                }
                if (this.data.length > backup.length && i+1 == currentBucket.length ) {
                    this.data[address] = backup;
                    console.log(elementForReturn);
                    return elementForReturn;
                }
                
            }
        }

        return undefined;

    }

Mateo Gutierrez Medina

student•

Mi solución:

import { HashTable } from "./hashTable";

export class Solution extends HashTable {
  constructor(size) {
    super()
    this.data = new Array(size);
  }

  delete(key) {
    // Tu código aquí 👈
    const address = this.hashMethod(key);
    let deletedItem;
    if (this.data[address]) {
      this.data[address].forEach((item, index) => {
        console.log('item', item)
        if (item[0] == key) {
          deletedItem = [...item]
          this.data[address].splice(index, 1)
        }
      })
      return (deletedItem)
    }

    return undefined
  }
}
```import { HashTable } from "./hashTable";
export class Solution extends HashTable {  constructor(size) {    super()    this.data = new Array(size);  }
&#x20; delete(key) {    // Tu código aquí 👈    const address = this.hashMethod(key);    let deletedItem;    if (this.data\[address]) {      this.data\[address].forEach((item, index) => {        console.log('item', item)        if (item\[0] == key) {          deletedItem = \[...item]          this.data\[address].splice(index, 1)        }      })      return (deletedItem)    }
&#x20;   return undefined  }}

Oscar Monsalve

student•

Mi solución:

delete(key){
      const address = this.hashMethod(key);
      const currentBucket = this.data[address];
  
      if (currentBucket) {
        let i = 0;
        let data;
        currentBucket.forEach((bucketItem, index) => {
          if (bucketItem[0] === key) {
            data = bucketItem;
            i = index;
          } else {
            return undefined;
          }
        })

        currentBucket.splice(i, 1);
        return data;
      }
    }

Andres giovanny lopez cortes

student•

mi solucion usando solo estructura

delete(key) { const address = this.hashMethod(key); const bucket = this.data[address]; return this.deleteMethod(bucket, key);

} deleteMethod(bucket, key) { if (bucket) { for (let i = 0; i < bucket.length; i++) { if (bucket[i][0] === key) { for (let j = i; j < bucket.length - 1; j++) { bucket[j] = bucket[j + 1] } bucket.length--; return true; } } } return false; }}

Edwar Sanchez

student•


import { HashTable } from "./hashTable";

export class Solution extends HashTable {
  constructor(size) {
    super()
    this.data = new Array(size);
  }

  delete(key){
    const address = this.hashMethod(key);
    const currentBucket = this.data[address];
    if (currentBucket) {
      for (let i = 0; i < currentBucket.length; i++) {
        if (currentBucket[i][0] === key) {
          let deletedSpace = currentBucket[i];
          currentBucket.splice(i, 1);
          return deletedSpace;
        }
      }
    }
  }
}

Erick Martinez

student•

Mi solución:

delete(key) {

const address = this.hashMethod(key);

const currentBucket = this.data[address];

if (!currentBucket) {

return undefined;

}

for (let i = 0; i < currentBucket.length; i++) {

if (currentBucket[i][0] === key) {

return currentBucket.splice(i, 1)[0]

}

José Eduardo Meza Gallardo

student•

  delete(key){
    const address = this.hashMethod(key);
    const data = this.data[address];
    if (!data) {
      return;
    }

    for (let count = 0; count < data.length; count++) {
      if (data[count][0] === key) {
        return this.data[address].splice(count, 1)[0];
      }
    }
    return;
  }
```  delete(key){    const address = this.hashMethod(key);    const data = this.data\[address];    if (!data) {      return;    }
&#x20;   for (let count = 0; count < data.length; count++) {      if (data\[count]\[0] === key) {        return this.data\[address].splice(count, 1)\[0];      }    }    return;  }

José Eduardo Meza Gallardo

student•

Mi solución

delete(key){ const address = this.hashMethod(key); const data = this.data[address]; if (!data) { return; } for (let count = 0; count < data.length; count++) { if (data[count][0] === key) { return this.data[address].splice(count, 1)[0]; } } return; }

Dilan Perdomo

student•

Dilan Perdomo

student•

import { HashTable } from "./hashTable";

export class Solution extends HashTable {
  constructor(size) {
    super()
    this.data = new Array(size);
  }

  delete(key){
    // Tu código aquí 👈
    const address = this.hashMethod(key);
    const currentBucket = this.data[address]
    //Validamos
    if (currentBucket) {
      for (let i = 0; i < currentBucket.length; i++) {
        if (currentBucket[i][0] === key) {
          return currentBucket.splice(i , 1)[0]
        }
      }      
    }
  }
}
```import { HashTable } from "./hashTable";
export class Solution extends HashTable {  constructor(size) {    super()    this.data = new Array(size);  }
  delete(key){    // Tu código aquí 👈    const address = this.hashMethod(key);    const currentBucket = this.data\[address]    //Validamos    if (currentBucket) {      for (let i = 0; i < currentBucket.length; i++) {        if (currentBucket\[i]\[0] === key) {          return currentBucket.splice(i , 1)\[0]        }      }          }  }}

Daniel Andres Rojas Paredes

student•

falle la ultima pruva, no supe del todo porque pero asumo que es por que mi codigo no tenia impelementado el reorganizar los arreglos al eliminar un elemento. igual lo quise provar asi. y estuvo cool, porque al darme cuenta que solo un caso de pruba no pasaba, la criosidad me llevo a ver la respuesta y de ahi me fui a leer el metodo splice, y lo que pense enn implementar reutilizando codigo de la clase anterior y ya me imaginaba como un quilimbo, se hizo facil por que splice ya lo implementa xd

Natalia Gallego Heras

student•

Conseguí pasar las pruebas sin utilizar el método .splice( ), tan solo las estructuras que veníamos utilizando como bucles, condicionales, delete...

Sin embargo, ¿por qué casi todo el mundo está utilizando ese método? Porque es perfecto para lo que necesitamos aquí:

El método .splice( ) ++modifica el array original quitando++, reemplazando o añadiendo elementos y además ++retorna un array con los elementos eliminados++
Su sintaxis utiliza tres parámetros: el índice desde el que empieza a modificar (start), el número de elementos que deseas eliminar (deleteCount) y los elementos que quieres añadir (item1, item2... itemN)

 .splice(start, deleteCount, item1, item2, /* …, */ itemN)

Aquí la documentación con ejemplos de MDN:
Por lo tanto, poder pasar por parámetro que el start es currentBucket[ i ] y que elimine 1 elemento, genera un código elegante y eficiente tanto para la máquina como para el programador

Daniel André Amaya López

student•

Mi solución

🤫

delete(key) {
    const address = this.hashMethod(key)
    const currentBuket = this.data[address]

    if (!currentBuket) return undefined

    const deletedSpace = currentBuket.find((item) => item[0] === key)
    const newBuket = currentBuket.filter((item) => item[0] !== key)
    this.data[address] = newBuket

    return deletedSpace
  }
```delete(key) {    const address = this.hashMethod(key)    const currentBuket = this.data\[address]
    if (!currentBuket) return undefined
    const deletedSpace = currentBuket.find((item) => item\[0] === key)    const newBuket = currentBuket.filter((item) => item\[0] !== key)    this.data\[address] = newBuket
    return deletedSpace  }

Daniel André Amaya López

student•

Mi solución

🤫

delete(key) {
    const address = this.hashMethod(key)
    const currentBuket = this.data[address]

    if (!currentBuket) return undefined

    const deletedSpace = currentBuket.find((item) => item[0] === key)
    const newBuket = currentBuket.filter((item) => item[0] !== key)
    this.data[address] = newBuket

    return deletedSpace
  }

  delete(key) {
    //* obtengo el hash del address
    const address = this.hashMethod(key)
    //* Obtengo el bucket donde debo buscar el espacio a eliminar
    const currentBucket = this.data[address]

    if (currentBucket) {
      //* recorriendo el espacio
      for (let i = 0; i < currentBucket.length; i++) {
        if (currentBucket[i][0] === key) {
          //* guardo el espacio para retornarlo luego
          let deletedSpace = currentBucket[i]
          //* elimino el espacio
          delete currentBucket[i]
          //* elimino el espacio vacio para que los demas espacios recorran
          currentBucket.splice(i, 1)
          return deletedSpace
        }
      }
    }
  }

import { HashTable } from "./hashTable";

export class Solution extends HashTable {
  constructor(size) {
    super()
    this.data = new Array(size);
  }

  delete(key){
    // Tu código aquí 👈
    const address = this.hashMethod(key);
    const currentBucket = this.data[address];
    let itemDeleted
    if (currentBucket) {
      for (let i = 0; i < currentBucket.length; i++) {
        if (currentBucket[i][0] === key) {
          const index = i
          itemDeleted = currentBucket[i]
          if (currentBucket.length > 1) {
            for (let i = index; i < currentBucket.length - 1; i++) {
              this.data[address][0] = this.data[address][i + 1];
            }
            delete this.data[address][currentBucket.length - 1]
            console.log("Se ha eliminado el elemento");
            return itemDeleted
          } else {
            delete this.data[address];
            console.log("Se ha liberado el Address");
            return itemDeleted
          }
        }
      }
    }
    console.log("No se encontro ningun elemento a borrar");
    return undefined
  }
}

delete(key) {
    const address = this.hashMethod(key)
    const bucket = this.data[address]
    // bucket data sample
    // [ [ 'Diego', 1990 ], [ 'Mariana', 2000 ] ]
    if (bucket) {
      // we search the index position for the bucket item that contains the incoming key
      const keyIndex = bucket.findIndex(([buckeItemtKey]) => buckeItemtKey === key)
      // if te item was found we delete the item using the splice method
      if (keyIndex !== -1) {
        return this.data[address].splice(keyIndex, 1)[0]
      }
    }
  }

delete(key) {
    const address = this.hashMethod(key)
    const currentBucket = this.data[address]
    if (currentBucket) {
      for (let i = 0; i < currentBucket.length; i++) {
        if (currentBucket[i][0] === key) {
          if (currentBucket.length > 1) {
            const itemDeleted = currentBucket[i]
            for (let o = 0; o < currentBucket.length; o++) {
              // el primer elemento será igual al que le sigue al primero
              currentBucket[o] = currentBucket[o + 1]
            }
            delete currentBucket[currentBucket.length - 1]
            currentBucket.length--
            return itemDeleted
          } else {
            delete this.data[address]
            return currentBucket[i]
          }
        }
      }
    }
    return undefined
  }

delete(key){
    const address = this.hashMethod(key);
    const currentBucket = this.data[address];
    if(currentBucket) {
      for (let i = 0; i < currentBucket.length; i++) {
        if(currentBucket[i][0] === key) {
          const deletedItem = this.data[address][i]
          this.data[address].splice(i, 1);
          return deletedItem;
        }
      }
    }
    return undefined
  }

    delete(key) {
        const address = this.hashMethod(key);
        const currentBucket = this.data[address];

        if (currentBucket) {
            for (let i = 0; i < currentBucket.length; i++) {
                let backup = [];
                var elementForReturn;
                if (currentBucket[i][0] === key) {
                    elementForReturn = [...this.data[address][i]];
                    delete this.data[address][i];
                } else {
                    if (true) {
                        backup.push(currentBucket[i]);
                    }
                }
                if (this.data.length > backup.length && i+1 == currentBucket.length ) {
                    this.data[address] = backup;
                    console.log(elementForReturn);
                    return elementForReturn;
                }
                
            }
        }

        return undefined;

    }

import { HashTable } from "./hashTable";

export class Solution extends HashTable {
  constructor(size) {
    super()
    this.data = new Array(size);
  }

  delete(key) {
    // Tu código aquí 👈
    const address = this.hashMethod(key);
    let deletedItem;
    if (this.data[address]) {
      this.data[address].forEach((item, index) => {
        console.log('item', item)
        if (item[0] == key) {
          deletedItem = [...item]
          this.data[address].splice(index, 1)
        }
      })
      return (deletedItem)
    }

    return undefined
  }
}
```import { HashTable } from "./hashTable";
export class Solution extends HashTable {  constructor(size) {    super()    this.data = new Array(size);  }
&#x20; delete(key) {    // Tu código aquí 👈    const address = this.hashMethod(key);    let deletedItem;    if (this.data\[address]) {      this.data\[address].forEach((item, index) => {        console.log('item', item)        if (item\[0] == key) {          deletedItem = \[...item]          this.data\[address].splice(index, 1)        }      })      return (deletedItem)    }
&#x20;   return undefined  }}

delete(key){
      const address = this.hashMethod(key);
      const currentBucket = this.data[address];
  
      if (currentBucket) {
        let i = 0;
        let data;
        currentBucket.forEach((bucketItem, index) => {
          if (bucketItem[0] === key) {
            data = bucketItem;
            i = index;
          } else {
            return undefined;
          }
        })

        currentBucket.splice(i, 1);
        return data;
      }
    }

import { HashTable } from "./hashTable";

export class Solution extends HashTable {
  constructor(size) {
    super()
    this.data = new Array(size);
  }

  delete(key){
    const address = this.hashMethod(key);
    const currentBucket = this.data[address];
    if (currentBucket) {
      for (let i = 0; i < currentBucket.length; i++) {
        if (currentBucket[i][0] === key) {
          let deletedSpace = currentBucket[i];
          currentBucket.splice(i, 1);
          return deletedSpace;
        }
      }
    }
  }
}

  delete(key){
    const address = this.hashMethod(key);
    const data = this.data[address];
    if (!data) {
      return;
    }

    for (let count = 0; count < data.length; count++) {
      if (data[count][0] === key) {
        return this.data[address].splice(count, 1)[0];
      }
    }
    return;
  }
```  delete(key){    const address = this.hashMethod(key);    const data = this.data\[address];    if (!data) {      return;    }
&#x20;   for (let count = 0; count < data.length; count++) {      if (data\[count]\[0] === key) {        return this.data\[address].splice(count, 1)\[0];      }    }    return;  }

import { HashTable } from "./hashTable";

export class Solution extends HashTable {
  constructor(size) {
    super()
    this.data = new Array(size);
  }

  delete(key){
    // Tu código aquí 👈
    const address = this.hashMethod(key);
    const currentBucket = this.data[address]
    //Validamos
    if (currentBucket) {
      for (let i = 0; i < currentBucket.length; i++) {
        if (currentBucket[i][0] === key) {
          return currentBucket.splice(i , 1)[0]
        }
      }      
    }
  }
}
```import { HashTable } from "./hashTable";
export class Solution extends HashTable {  constructor(size) {    super()    this.data = new Array(size);  }
  delete(key){    // Tu código aquí 👈    const address = this.hashMethod(key);    const currentBucket = this.data\[address]    //Validamos    if (currentBucket) {      for (let i = 0; i < currentBucket.length; i++) {        if (currentBucket\[i]\[0] === key) {          return currentBucket.splice(i , 1)\[0]        }      }          }  }}

delete(key) {
    const address = this.hashMethod(key)
    const currentBuket = this.data[address]

    if (!currentBuket) return undefined

    const deletedSpace = currentBuket.find((item) => item[0] === key)
    const newBuket = currentBuket.filter((item) => item[0] !== key)
    this.data[address] = newBuket

    return deletedSpace
  }
```delete(key) {    const address = this.hashMethod(key)    const currentBuket = this.data\[address]
    if (!currentBuket) return undefined
    const deletedSpace = currentBuket.find((item) => item\[0] === key)    const newBuket = currentBuket.filter((item) => item\[0] !== key)    this.data\[address] = newBuket
    return deletedSpace  }

delete(key) {
    const address = this.hashMethod(key)
    const currentBuket = this.data[address]

    if (!currentBuket) return undefined

    const deletedSpace = currentBuket.find((item) => item[0] === key)
    const newBuket = currentBuket.filter((item) => item[0] !== key)
    this.data[address] = newBuket

    return deletedSpace
  }

Playground: implementa el metodo Delete

Introducción a las estructuras de datos

Estructuras de Datos en JavaScript para Desarrolladores

Estructuras de Datos: Conceptos Básicos y Aplicaciones Prácticas

Almacenamiento de Datos en Memoria con JavaScript

Arrays y strings

Cómo funcionan arrays en memoria de JavaScript

Construcción de Arrays con Clases en JavaScript

Métodos pop y delete en arrays

Playground: crea tu propia implementación de unshift

Playground: crea tu propia implementación de shift

Inmutabilidad de Strings y Almacenamiento en Memoria

Hash Table

Conceptos y Construcción de Hash Tables en JavaScript

Implementación de Hash Table en JavaScript: Método Set

Implementación del método get en hash table JavaScript

Playground: implementa el metodo Delete

Playground: implementa el método getAllKeys

Linked List

Estructuras de Datos: Listas Enlazadas en JavaScript

Estructura y Creación de una Lista Enlazada Simple en JavaScript

Métodos para Manipular Nodos en Listas Enlazadas

Inserta nodos intermedios sin romper enlaces en JavaScript

Doubly Linked List con punteros bidireccionales

Stacks

Stacks: Concepto y Operaciones Básicas en JavaScript

Implementación de Stacks en JavaScript: Métodos Push y Peek

Queues

Qué es queue y cómo funciona FIFO

Implementación del método enqueue en JavaScript

Trees

Estructuras de Datos: Árboles Binarios y Búsqueda en JavaScript

Construcción y validación de un Árbol de Búsqueda Binaria en JavaScript

Graphs

Conceptos básicos de grafos: tipos y aplicaciones prácticas

Representación visual de grafos en JavaScript

Construcción de Grafos: Método Lista de Adyacencia en JavaScript

Cierre

Estructuras de Datos con JavaScript: Práctica y Aplicación