Playground - Agrega métodos a la singly linked list

Cursos Empresas Blog Live Conf Precios

Contenido del curso

¡Te damos la bienvenida a este reto!

1
¡Bienvenido al mundo de JavaScript!
01:33 min

Día 1

Día 2

Día 3

Día 4

Día 5 - Checkpoint

20
Playground - encuentra el palindromo más grande

Día 6

Día 7

Día 8

Día 9

Día 10 - Checkpoint

Día 11

Día 12

Día 13

Día 14

Día 15 - Checkpoint

50
Playground - Sistema de reservaciones de un hotel

Día 16

Día 17

Día 18

Día 19

Día 20 - Checkpoint

65
Playground - Agenda de vuelos

Día 21

Día 22

Día 23

Día 24 - Checkpoint

77
Playground - Crea un task manager con patrones de diseño

Día 25

Día 26

Día 27

Día 28

Día 29

Día 30

93
¡Lo lograste!
01:41 min

Live Class

Tomar examen

Playground - Agrega métodos a la singly linked list

Agustin Choque Veliz

student

Mi solución: . . . . . . . . . . .

import { LinkedList } from "./SinglyLinkedList";
import { Node } from "./Node";

export class LinkedListRecharged extends LinkedList {
  get(index){
    if (index < 0 || index >= this.length) {  // index fuera de rango
      return null;
    }
    let nodeCurrent = this.head;
    let i = 0;
    while (i!=index) {
      nodeCurrent = nodeCurrent.next;
      i++;
    }
    return nodeCurrent.value;
  }

  insertAt(index, value){
    if (index < 0 || index > this.length-1) {
      return null;
    }
    if (index == 0) {  //si el indice es 0 se inserta al principio
      this.prepend(value);
      return this;
    }
    if (index == this.length) {  //si el indice es igual a length, se inserta al final
      this.append(value);
      return this;
    }
    if (index > 0 && index < this.length - 1) {  //si el indice está en el medio
      const newNode = new Node(value);
      const nodoPrev = this.nodeSearch(index - 1) //buscamos al nodo previo

      newNode.next = nodoPrev.next //newNodo apunta al Nodo Posterior
      nodoPrev.next = newNode;     //nodo previo apunta al nuevo nodo
      this.length++;
      return this;
    }
  }

  toArray(){
    let values = [];
    let pointer = this.head;
    for (let i = 0; i < this.length; i++) {
      values.push(pointer.value);
      pointer = pointer.next;
    }
    return values;
  }

  removeAt(index){
    if (index < 0 || index > this.length-1) {
      return null;
    }
    if (index == 0) {  //se elimina el primer nodo
      this.head = this.head.next;
      this.length--;
      return this;
    }
    if (index == this.length - 1) {  //se elimina el último nodo
      const nodoPrev = this.nodeSearch(index - 1);
      this.tail = nodoPrev;
      nodoPrev.next = null;
      this.length--;
      return this;
    }
    if (index > 0 && index < this.length - 1) {  //si el indice está al medio
      const nodoPrev = this.nodeSearch(index - 1) //buscamos al nodo previo
      const nodoPost = this.nodeSearch(index + 1) //buscamos al nodo posterior
      nodoPrev.next = nodoPost; //el nodo previo ahora apunta al nodo posterior
      this.length--;
      return this;
    }
  }

  nodeSearch(index) {
    let pointerSearch = this.head;
    let i = 0;
    if (index < 0 || index >= this.length) {
      throw new Error("El índice esta fuera de rango");
    }
    while (i != index && pointerSearch.next != null) {
      pointerSearch = pointerSearch.next;
      i++;
    }
    return pointerSearch;
  }
}

Harold Zurita Simon

Hola, en el método insertAt(index, value) tienes la condición de que 'index' tiene que ser mayor al tamaño de la lista -1:

if (index < 0 || index > this.length - 1) {
      return null;
    }

Pero más abajo, se tiene también:

if (index == this.length) {  //si el indice es igual a length, se inserta al final
      this.append(value);
      return this;
    }

. Por lo que 'index' nunca va a ser igual a 'this.length', debido a la primera condición. Por ende no se podrá insertar un nodo al final de la lista. . Podrías resolverlo modificando la primera condición: .

if (index < 0 || index > this.length) {
      return null;
    }

. Pero si lo haces el playground marca error 😅, porque no permite un 'index' fuera de rango, que puede ser el caso de un 'index' igual al tamaño de la lista.

Carina Payleman

. . . . . .

class LinkedListRecharged extends LinkedList {
    get(index){
        if (!this.head) {
            return null;
        }
        let counter = 0;
        let currentNode = this.head;
        while (counter != index) {
            if (currentNode.next === null) {
            return null;
            }
            currentNode = currentNode.next;
            counter++;
        }
        return currentNode.value;
    }

    insertAt(index, value) {
        if (index < 0 || index > this.length) return null;
        const newNode = new Node(value);
        let currentNode = this.head;
        let previousNode = null;
        for (let i = 0; i < index; i++) {
            previousNode = currentNode;
            currentNode = currentNode.next;
        }
        if (!previousNode) {
            this.prepend(value);
        } else if (!currentNode) {
            this.append(value);
        } else {
            newNode.next = currentNode;
            previousNode.next = newNode;
            this.length++;
        }
        return null;
    }
  
    toArray() {
        let values = [];
        let currentNode = this.head;
        while (currentNode) {
            values.push(currentNode.value);
            currentNode = currentNode.next;
        }
        return values;
    }
  
    removeAt(index) {
        const value = this.get(index);
        index < 0 || index >= this.length ? null : this.delete(value);
        return value;
    }
}

Osvaldo Martinez Guillen

Bien, podría ser mejor, aun soy noob.

++Exercise.js++

import { LinkedList } from "./SinglyLinkedList";
import { Node } from "./Node";

export class LinkedListRecharged extends LinkedList {
  get(index) {
    if (!this.head) {
      return null;
    }
    let counter = 0;
    let currentNode = this.head;
    while (counter != index) {
      if (currentNode.next === null) {
        return null;
      }
      currentNode = currentNode.next;
      counter++;
    }
    return currentNode.value;
  }

  insertAt(index, value) {
    let newNode = new Node(value), counter = 0;
    let currentNode = this.head;
    if (index >= this.length || index < 0) {
      return null;
    }
    if (index === 0) {
      newNode.next = this.head;
      this.head = newNode
      this.length++;
      return;
    } else {
      while (counter != (index - 1)) {
        if (currentNode.next === null) {
          this.tail.next = newNode;
          this.tail = newNode;
          this.length++;
          return;
        }
        currentNode = currentNode.next;
        counter++;
      }
        newNode.next = currentNode.next;
        currentNode.next = newNode;
        this.length++;
        return;
    }
  }

  toArray() {
    let currentNode = this.head;
    let values = [];
    while (currentNode) {
      values.push(currentNode.value);
      currentNode = currentNode.next;
    }
    return values;
  }

  removeAt(index) {
    if (!this.head) {
      return null;
    }
    let counter = 0;
    let currentNode = this.head;
    while (counter != index - 1) {
      currentNode = currentNode.next;
      if (currentNode.next === null) {
        return null;
      }
      counter++;
    }
    let deleted = currentNode.value;
    currentNode.next = currentNode.next.next;
    this.length--;
    return deleted;
  }
}

Joan Alexander Valerio Rodríguez

Jacobo Burbano

Al parecer tengo un error en el método insertAt() pero cuando corro mi código en un editor funciona correctamente. . . . . . . . . . . . . .

  get(index){
        if(index > this.length - 1 ){
            return null
        }
    let currentNode = this.head
    for(let i = 0; i !== index; i++){
        currentNode = currentNode.next //Lo que hay que tener en cuenta 
    }
    return currentNode.value
}
       insertAt(index, value){
        let currentNode = this.head
        if(index >= this.length || index < 0) {
            return null
        }
        else if(index === 0){
            this.prepend(value)
        }
        else if(index === this.length - 1){
            this.append(value)
        }
        else {
            let i = 0
            while(i < index){
            currentNode = currentNode.next
            i++
        }
        currentNode.value = value// Remplazo
        this.length++
    } 
       }
     
       toArray(){
        let currentNode = this.head
        let valoresEstructuraLineal = []
        for(let i = 0; i !== this.length; i++){
            valoresEstructuraLineal.push(currentNode.value)
            currentNode = currentNode.next
        }
    return valoresEstructuraLineal
       }
       removeAt(index){
        let nodeDelete = this.head
        for(let i = 0; i !== index; i++){
        nodeDelete = nodeDelete.next //Lo que hay que tener en cuenta 
        }
        return this.delete(nodeDelete.value)
    }
}

Angel Javier Sanchez Tenjo

Hola la solución, con ayuda de los comnentarios.

✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅

import { LinkedList } from "./SinglyLinkedList";
import { Node } from "./Node";

export class LinkedListRecharged extends LinkedList {
  get(index) {
    if (index < 0 || index >= this.length) {
      return null;
    }

    let currentNode = this.head;
    for (let i = 0; i < index; i++) {
      currentNode = currentNode.next;
    }

    return currentNode.value;
  }

  insertAt(index, value) {
    if (index < 0 || index >= this.length) {
      return null;
    }

    const newNode = new Node(value);

    if (index === 0) {
      newNode.next = this.head;
      this.head = newNode;

      if (!this.tail) {
        this.tail = newNode;
      }

      this.length++;

      return newNode;
    }

    let currentNode = this.head;
    for (let i = 0; i < index - 1; i++) {
      currentNode = currentNode.next;
    }

    newNode.next = currentNode.next;
    currentNode.next = newNode;

    if (!newNode.next) {
      this.tail = newNode;
    }

    this.length++;
    return newNode;
  }

  toArray() {
    const result = [];
    let currentNode = this.head;
    while (currentNode) {
      result.push(currentNode.value);
      currentNode = currentNode.next;
    }

    return result;
  }

  removeAt(index) {
    if (index < 0 || index >= this.length) {
      return null;
    }

    let deletedNode = null;

    if (index === 0) {
      deletedNode = this.head;
      this.head = this.head.next;
      if (this.length === 1) {
        this.tail = null;
      }
      this.length--;
      return deletedNode.value;
    }

    let currentNode = this.head;

    for (let i = 0; i < index - 1; i++) {
      currentNode = currentNode.next;
    }

    deletedNode = currentNode.next;
    currentNode.next = currentNode.next.next;

    if (!currentNode.next) {
      this.tail = currentNode;
    }

    this.length--;
    return deletedNode.value;
  }
}

Victor Ortiz

Mi solucion: . . . . . . . . . . . . . . . . . . . . .

import { LinkedList } from "./SinglyLinkedList";
import { Node } from "./Node";

export class LinkedListRecharged extends LinkedList {
  get(index){
    // Tu código aquí 👈
    if (index < 0 || index >= this.length)
      return null;
    let currentNode = this.head;
    for (let i = 0; i <= this.length - 1; i++) {
      if (index === i)
        return currentNode.value;
      currentNode = currentNode.next;
    }
  }

  insertAt(index, value){
    // Tu código aquí 👈
    const newNode = new Node(value);
    if (index < 0 || index >= this.length)
      return null;
    if (index === 0) {
      this.prepend(value);
      return;
    }
    if (index === this.length) {
      this.append(value);
      return;
    }
    let currentNode = this.head;
    let prevNode;
    for (let i = 0; i <= this.length - 1; i++) {
      if (index === i) {
        newNode.next = currentNode;
        prevNode.next = newNode;
        this.length++;
        return;
      }
      prevNode = currentNode;
      currentNode = currentNode.next;
    }  
  }

  toArray(){
    // Tu código aquí 👈
    const nodes = [];
    let currentNode = this.head;
    for (let i = 1; i <= this.length; i++) {
      nodes.push(currentNode.value);
      if (i < this.length)
        currentNode = currentNode.next;
    }
    return nodes;
  }

  removeAt(index){
    // Tu código aquí 👈
    if (index < 0 || index >= this.length)
      return null;
    if (index === 0) {
      this.delete(this.head.value);
      return;
    }
    let currentNode = this.head;
    let i = 1;
    while (currentNode.next) {
      if (index === i) {
        let retValue = currentNode.next.value;
        currentNode.next = currentNode.next.next;
        this.length--;
        return retValue;
      }
      currentNode = currentNode.next;
      i++;
    }
  }
}

Rubén Hernández Hernández

💚Mi Solución💚

🛡️MURO ANTI-SPOILERS🛡️

!cats

🎯Nota

La mayoría de mi código esta comentado en algunas partes para comprender que se hace en cada bloque de código. Sin embargo, me gustaría puntualizar que en el método insertAt() las pruebas consideran un indice fuera de los límites el que sea igual a el length, en mi caso quise dejar mi código con el caso en el que es igual al length que en otras palabras es añadir a la cola. Si requieren hacer pasar las pruebas solamente en el primer if de ese metodo es cambiar index > this.length por index >= this.length y eliminar el código del Caso2 (porque no se ocupa). Sin duda alguna recorrer la SinglyLinkedList es fácil, pero lo dificil es insertar o remover los apuntadores a nodo siguiente. Recomiendo mucho hacer un dibujo con flechitas para que se observe como cambian los apuntadores.

👁️ Nota

En el método delete() proporcionado en clase no hay ningún problema al remover en medio o en cabeza. Sin embargo, al remover en cola el método si lo elimina efectivamente pero falta actualizar this.tail, solo sería agregar una validación para actualizarlo.

👾Código

import { LinkedList } from "./SinglyLinkedList";
import { Node } from "./Node";

export class LinkedListRecharged extends LinkedList {
  get(index) {
    if (index >= this.length || index < 0 )
      return null

    let actualNode = this.head;
    while (index > 0) {
      actualNode = actualNode.next
      index--
    }

    return actualNode.value 
  }

  insertAt(index, value) {
    if (index > this.length || index < 0)
      return null //Index out of bounds

    //Caso1: Se añade en la cabeza
    if (index == 0) {
      this.prepend(value)
      return
    }

    //Caso2: Se añade en la cola
    if (index == this.length) {
      this.append(value)
      return
    }

    //Caso3: Se añade en el medio
    let actualNode = this.head
    while (index > 1) {
      actualNode = actualNode.next
      index--
    }
    //El actualNode es un nodo antes de donde queremos insertar
    const nodeToInsert = new Node(value)
    const nextOfNodeToInsert = actualNode.next
    actualNode.next = nodeToInsert
    nodeToInsert.next = nextOfNodeToInsert
    this.length++
  }

  toArray() {
    const array = []
    let actualNode = this.head
    for (let i = 0; i < this.length; i++){
      array.push(actualNode.value)
      actualNode=actualNode.next
    }
    return array
  }

  removeAt(index) {
    if (index >= this.length || index < 0) 
      return null //Index out of bounds

    let value = null

    //Caso1: Se quiere eliminar la cabeza
    if (index === 0) {
      value = this.head.value
      this.head = this.head.next

      if (--this.length === 0) //Si eliminamos ya todo
        this.tail = null

      return value
    }

    //Caso2: Se quiere eliminar en medio o en cola

    //Obtenemos un nodo previo al que queremos eliminar
    let actualPrevNode = this.head;
    while (index > 1) {
      actualPrevNode = actualPrevNode.next
      index--
    }

    value = actualPrevNode.next.value
    //Hilamos al nodo siguiente del que queremos eliminar
    actualPrevNode.next = actualPrevNode.next.next

    //Caso3: En que el nodo que eliminamos fue la cola
    if (actualPrevNode.next === null)
      this.tail = actualPrevNode

    this.length--
    return value
  }
}

Alejandro Anaya

🛡️🛡️Escudo anti-spoilers🛡️🛡️ Mi solución al reto:

import { LinkedList } from "./SinglyLinkedList";
import { Node } from "./Node";

export class LinkedListRecharged extends LinkedList {
  get(index) {
    if (index < 0 || index > this.length - 1) return null
    let currentNode = this.head
    let counter = 0
    while (currentNode) {
      if (index === counter) return currentNode.value
      currentNode = currentNode.next
      counter++
    }
  }

  insertAt(index, value) {
    if (index < 0 || index > this.length - 1) return null
    let newNode = new Node(value)
    let currentNode = this.head
    let temp = null
    let lastNode = null
    //is head
    if (index === 0) {
      temp = currentNode
      this.head = newNode
      this.head.next = temp
      return true
    }
    let counter = 0
    while (currentNode) {
      if (index === counter) {
        temp = currentNode
        lastNode.next = newNode
        newNode.next = temp
        this.length++;
        return true
      }
      lastNode = currentNode
      currentNode = currentNode.next
      counter++
    }
    return false
  }

  toArray() {
    let myArray = []
    let currentNode = this.head
    while (currentNode) {
      myArray.push(currentNode.value)
      currentNode = currentNode.next
    }
    return myArray
  }

  removeAt(index) {
    if (index < 0 || index > this.length - 1) return null
    let currentNode = this.head
    let temp = null
    let lastNode = null
    let value = null
    //is head
    if (index === 0) {
      value = this.head.value
      this.head = this.head.next
      return value
    }

    let counter = 0
    while (currentNode) {
      if (index === counter) {
        value = currentNode.value
        temp = currentNode.next
        lastNode.next = temp
        return value
      }
      lastNode = currentNode
      currentNode = currentNode.next
      counter++
    }
  }
}

Victor Hernandez

import { LinkedList } from "./SinglyLinkedList";
import { Node } from "./Node";

export class LinkedListRecharged extends LinkedList {
  get(index){
    if (!this.head || index >= this.length || index < 0) {
      return null;
    }

    let node = this.head;
    let i = 0;
    while (i < index) {
      node = node.next;
      i++;
    }
    return node.value;
  }

  insertAt(index, value){
    if (!this.head || index >= this.length || index < 0) {
      return null;
    }

    let prevNode = null;
    let node = this.head;
    let i = 0;
    while (i < index) {
      prevNode = node;
      node = node.next;
      i++;
    }
    const newNode = new Node(value);
    if (prevNode) {
      prevNode.next = newNode;
    }
    newNode.next = node;
    node = newNode;
  }

  toArray(){
    if (!this.head) {
      return null;
    }
    const array = [];
    array.push(this.head.value);
    let currentNode = this.head;
    while (currentNode.next) {
      array.push(currentNode.next.value);
      currentNode = currentNode.next;
    }
    return array;
  }

  removeAt(index){
    if (!this.head || index >= this.length || index < 0) {
      return null;
    }

    let prevNode = null;
    let node = this.head;
    let i = 0;
    let value = null;
    while (i < index) {
      prevNode = node;
      node = node.next;
      i++;
    }
    value = node.value;
    if (prevNode) {
      prevNode.next = node.next;  
    }
    
    return value;
  }
}

JAIME EDUARDO DIAZ TOBON

++MI SOLUCION++ 💪 . . . . . . . . . . . . . . . . . .

import { LinkedList } from "./SinglyLinkedList";
import { Node } from "./Node";

export class LinkedListRecharged extends LinkedList {
  getNodo(index) {
    if (index < 0 || index >= this.length) return null;
    let currentNodo = this.head;
    for (let i = 0; i < index; i++) {
      currentNodo = currentNodo.next;
    }
    return currentNodo;
  }

  get(index){
    const nodo = this.getNodo(index);
    return nodo ? nodo.value : null;
  }

  insertAt(index, value){
    if (index < 0 || index >= this.length) return null;
    if (index === 0) {
      this.prepend(value);
      return;
    }
    if (index === this.length - 1) {
      this.append(value);
      return;
    }
    const newNodo = new Node(value);
    const prevNodo = this.getNodo(index - 1);
    newNodo.next = prevNodo.next;
    prevNodo.next = newNodo;
    this.length++;
    return;
  }

  toArray() {
    const values = [];
    let currentNodo = this.head;
    for (let i = 0; i < this.length; i++) {
      values.push(currentNodo.value);
      currentNodo = currentNodo.next;
    }
    return values;
  }

  removeAt(index){
    if (index < 0 || index >= this.length) return null;
    const value = this.get(index);
    this.delete(value);
    return value;
  }
}

Alexis Corrales

export class LinkedListRecharged extends LinkedList {
  get(index) {
    if (index < 0 || index >= this.length) {
      return null;
    }

    let current = this.head;
    for (let i = 0; i < index; i++) {
      current = current.next;
    }

    return current.value;
  }

  insertAt(index, value) {
    if (index < 0 || index >= this.length) {
      return null
    }

    const newNode = new Node(value)
    if (index === 0) {
      newNode.next = this.head
      this.head = newNode
      if (!this.tail) {
        this.tail = newNode
      }
      this.length++

      return newNode
    }
    let currentNode = this.head
    for (let i = 0; i < index - 1; i++) {
      currentNode = currentNode.next
    }

    newNode.next = currentNode.next
    currentNode.next = newNode

    if (!newNode.next) {
      this.tail = newNode
    }

    this.length++
    return newNode

  }

  toArray() {
    const arr = [];
    let current = this.head;
    while (current) {
      arr.push(current.value);
      current = current.next;
    }
    return arr;
  }

  removeAt(index) {
    if (index < 0 || index >= this.length) {
      return null;
    }

    let removedValue;
    if (index === 0) {
      removedValue = this.head.value;
      this.head = this.head.next;
    } else {
      let current = this.head;
      for (let i = 0; i < index - 1; i++) {
        current = current.next;
      }
      removedValue = current.next.value;
      current.next = current.next.next;
    }

    this.length--;
    return removedValue;
  }
}

David Esteban Giraldo Duque

Mi solución: . . . . . . . .

import { LinkedList } from "./SinglyLinkedList";
import { Node } from "./Node";

export class LinkedListRecharged extends LinkedList {
  get(index){
    if (index >= this.length || index < 0) {
     return null
    }
    let currentNode = this.head
    for (let i = 0; i < index; i++) {
      currentNode = currentNode.next
    }
    return currentNode.value
  }

  insertAt(index, value){
    if (index >= this.length || index < 0) {
      console.log(null)
      return null
    }
    if (index === 0) {
      this.prepend(value)
      return
    }
    if (index == this.length - 1) {
      this.append(value)
      return
    }
    let currentNode = this.head
    let nextNode = currentNode.next
    for (let i = 0; i < index - 1; i++) {
      currentNode = currentNode.next
      nextNode = currentNode.next
    }
    const newNode = new Node(value)
    currentNode.next = newNode
    newNode.next = nextNode
    this.length++
  }

  toArray(){
    let array = []
    let currentNode = this.head
    for (let i = 0; i < this.length; i++) {
      array.push(currentNode.value)
      currentNode = currentNode.next
    }
    return array
  }

  removeAt(index){
    const value = this.get(index)
    this.delete(value)
    return value
  }
}

Solución… 😄 . Reto interesante, creo que el playground en el método 'insertAt' no permite insertar un nodo al final de la lista, porque el 'index' saldría fuera de rango. . Pero aún así adjunto la solución del playground y la solución que permite insertar un nodo al final de la lista utilizando el método 'insertAt' si lo quieren ver 😄. .

. Solución del playground:

import { LinkedList } from "./SinglyLinkedList";
import { Node } from "./Node";

export class LinkedListRecharged extends LinkedList {
  get(index) {
    if (index >= this.length || index < 0) {
      return null;
    }
    
    let currentNode = this.head;

    while (index) {
      currentNode = currentNode.next;
      index--;
    }

    return currentNode.value;
  }

  insertAt(index, value) {
    let newNode = new Node(value);

    if (index >= this.length || index < 0) {
      return null;
    }

    if (index === 0) {
      this.prepend(value);
      return this;
    }

    if (index === this.length) {
      this.append(value);
      return this;
    }

    let preNode = this.head;
    index--;

    while (index) {
      preNode = preNode.next;
      index--;
    }

    newNode.next = preNode.next;
    preNode.next = newNode;
    this.length++;
    return this;
  }

  toArray() {
    let currentNode = this.head;
    let res = [];

    while (currentNode) {
      res.push(currentNode.value);
      currentNode = currentNode.next;
    }

    return res;
  }

  removeAt(index) {
    if (index >= this.length || index < 0) {
      return null;
    }

    if (index === 0) {
      this.head = this.head.next;
      this.length--;
      return this;
    }

    let preNode = this.head;
    index--;

    while (index) {
      preNode = preNode.next;
      index--;
    }

    preNode.next = preNode.next.next;
    if (preNode.next === null) {
      this.tail = preNode;
    }
    
    this.length--;
    return this;
  }
}

. Solución (no pasa la prueba del playground, pero se puede verificar en la pestaña 'Vista´ del mísmo) que permite agregar un nodo al final de la lista:

import { LinkedList } from "./SinglyLinkedList";
import { Node } from "./Node";

export class LinkedListRecharged extends LinkedList {
  get(index) {
    if (index >= this.length || index < 0) {
      return null;
    }
    
    let currentNode = this.head;

    while (index) {
      currentNode = currentNode.next;
      index--;
    }

    return currentNode.value;
  }

  insertAt(index, value) {
    let newNode = new Node(value);

    if (index > this.length || index < 0) {
      return null;
    }

    if (index === 0) {
      this.prepend(value);
      return this;
    }

    if (index === this.length) {
      this.append(value);
      return this;
    }

    let preNode = this.head;
    index--;

    while (index) {
      preNode = preNode.next;
      index--;
    }

    newNode.next = preNode.next;
    preNode.next = newNode;
    this.length++;
    return this;
  }

  toArray() {
    let currentNode = this.head;
    let res = [];

    while (currentNode) {
      res.push(currentNode.value);
      currentNode = currentNode.next;
    }

    return res;
  }

  removeAt(index) {
    if (index >= this.length || index < 0) {
      return null;
    }

    if (index === 0) {
      this.head = this.head.next;
      this.length--;
      return this;
    }

    let preNode = this.head;
    index--;

    while (index) {
      preNode = preNode.next;
      index--;
    }

    preNode.next = preNode.next.next;
    if (preNode.next === null) {
      this.tail = preNode;
    }
    
    this.length--;
    return this;
  }
}

Gonzalo Gutiérrez Castillo

Mi solución: Después de revisar otros algoritmos. Creo que mi propuesta es un poco más legible: . . . . . . .

import { LinkedList } from "./SinglyLinkedList";
import { Node } from "./Node";

export class LinkedListRecharged extends LinkedList {
  get(index){
    let currentNode = this.head;
    if (index>=0&&index < this.length) {
      for (let i = 0; i < this.length; i++) {
        if (i !== index) {
          currentNode = currentNode.next
        } else {
          return currentNode.value
        }
      }
    } else {
      return null
    }   
  }

  insertAt(index, value){
    let currentNode = this.head;
    const newNode = new Node(value)
    if (index>=0&&index < this.length) {
      for (let i = 0; i < this.length; i++) {
        if (i !== index-1) {
          if (currentNode.next) currentNode = currentNode.next

        } else {
          newNode.next = currentNode.next
          currentNode.next=newNode
          this.length++
          return
        }
      }
    } else {
      return null
    }   
  }

  toArray(){
    const arrLinkedList = () => {
      const array = []
      let currentNode = this.head;
      for (let i = 0; i < this.length; i++) {
        array.push(currentNode.value)
        if (currentNode.next) currentNode = currentNode.next
      }
      return array
    }
    return arrLinkedList()
  }

  removeAt(index){
    let currentNode = this.head;
    if (index>=0&&index < this.length) {
      for (let i = 0; i < this.length; i++) {
        if (i !== index-1) {
          if (currentNode.next) currentNode = currentNode.next

        } else {
          const removed =  currentNode.next
          currentNode.next = currentNode.next.next
          this.length--
          return removed
        }
      }
    } else {
      return null
    }   
  }
}

Elias Rayas Gonzalez

Solucion

Necesite revisarlo muchas veces antes de entender bien el funcionamiento de los LinkedLists. + + + + + + + + + +

class LinkedListRecharged extends LinkedList {
  get(index) {
    // Tu código aquí 👈

    if (index < 0 || index > this.length) return null;

    let counter = 0;
    let currentNode = this.head;

    while (currentNode) {
      if (counter === index) {
        return currentNode;
      }
      currentNode = currentNode.next;
      counter++;
    }
  }

  insertAt(index, value) {
    // Tu código aquí 👈

    // Check for head and tail position
    if (index < 0 || index >= this.length) return null;

    // Create node

    // insert node at head
    if (index === 0) this.prepend(value);
    else if (index === this.length - 1) this.append(value);
    else {
      const newNode = new Node(value);
      const prevNode = this.get(index - 1);

      newNode.next = prevNode.next;
      prevNode.next = newNode;
      this.length++;

      return newNode;
    }
  }

  toArray() {
    // Tu código aquí 👈
    let arrayFromLinkedList = new Array(this.length);
    let currentNode = this.head;
    let i = 0;
    while (currentNode) {
      arrayFromLinkedList[i] = currentNode.value;
      currentNode = currentNode.next;
      i++;
    }
    console.log(arrayFromLinkedList);
    return arrayFromLinkedList;
  }

  removeAt(index) {
    // Tu código aquí 👈

    if (index < 0 || index >= this.length) return null;

    if (index === 0 || index === this.length - 1) {
      const deletedNode = this.get(index);
      this.delete(deletedNode.value);
      return deletedNode;
    } else {
      const prevNode = this.get(index - 1);
      const removedNode = prevNode.next;
      const realocatedNode = removedNode.next;

      prevNode.next = realocatedNode;
      this.length--;
      return removedNode.value;
    }
  }
}

Gabriel Luna

Aquí mi solución: . . . . . . . . . . . .

class LinkedListRecharged extends LinkedList {
  get(index) {

    if (index < 0 && index > this.length) {
      return null;
    }

    if (!this.head) {
      return null;
    }

    let ii = 0;
    let currentNode = this.head;
    while (ii <= this.length) {
      if (ii === index) {
        return currentNode.value;
      }
      if (currentNode.next) {
        currentNode = currentNode.next;
        ii++
      } else {
        return null;
      }
    }
  }

  insertAt(index, value) {

    if (index < 0 && index > this.length) {
      return null;
    }

    if (!this.head) {
      return null;
    }

    let ii = 0;
    let currentNode = this.head;
    let newNode;
    let antNode;
    while (ii <= this.length) {
      if (ii === (index - 1)) {
        antNode = currentNode;
      } else if (ii === index) {
        newNode = new Node(value);
        newNode.next = currentNode;
        antNode.next = newNode;
        if (ii === 0) {
          this.head = newNode;
        } else if (ii === this.length) {
          this.tail = newNode;
        }
      }
      if (currentNode.next) {
        currentNode = currentNode.next;
        ii++
      } else {
        return null;
      }
    }
  }

  toArray() {
    let newarray = [];
    if (!this.head) {
      return null;
    }
    // Si el nodo a eliminar es el primer nodo en la lista
    // se recorre la lista buscando el nodo anterior al que se quiere eliminar
    let currentNode = this.head;
    while (currentNode.next) {
      newarray.push(currentNode.value)
      currentNode = currentNode.next;
    }
    newarray.push(currentNode.value)
    return newarray;
  }

  removeAt(index) {
    if (index <= 0 || index >= this.length) {
      return null;
    }

    if (!this.head) {
      return null;
    }

    if (index === 0) {
      this.head = this.head.next;
      this.length--;
      return this.length;
    }

    let ii = 0;
    let antNode;
    let currentNode = this.head;

    while (ii <= this.length) {
      if (ii === (index - 1)) {
        antNode = currentNode;
      } else if (ii === index) {
        if (currentNode.next) {
          antNode.next = currentNode.next
        } else {
          antNode.next = null
        }
        this.length--
        if (ii === this.length) {
          this.tail = newNode;
        }
        return this.length;
      }
      if (currentNode.next) {
        currentNode = currentNode.next;
        ii++
      }
    }
  }
}

Raul Carrillo Garrido

, , , , , , , , , , ,

import { LinkedList } from "./SinglyLinkedList";
import { Node } from "./Node";

export class LinkedListRecharged extends LinkedList {
  get(index) {
    if (index < 0 || index >= this.length) {
      return null;
    }
    let current = this.head;
    for (let i = 0; i < index; i++) {
      current = current.next;
    }
    return current.value;
  }

  insertAt(index, value) {
    if (index < 0 || index >= this.length) {
      return null;
    }
    const newNode = new Node(value);
    if (index === 0) {
      newNode.next = this.head;
      this.head = newNode;
    } else {
      let current = this.head;
      for (let i = 0; i < index - 1; i++) {
        current = current.next;
      }
      newNode.next = current.next;
      current.next = newNode;
    }
    this.length++;
    return newNode;
  }

  toArray() {
    const array = [];
    let current = this.head;
    while (current) {
      array.push(current.value);
      current = current.next;
    }
    return array;
  }

  removeAt(index) {
    if (index < 0 || index >= this.length) {
      return null;
    }
    let removedNode;
    if (index === 0) {
      removedNode = this.head;
      this.head = this.head.next;
    } else {
      let current = this.head;
      for (let i = 0; i < index - 1; i++) {
        current = current.next;
      }
      removedNode = current.next;
      current.next = current.next.next;
    }
    this.length--;
    return removedNode.value;
  }
}

Esteban Alzate Atehortua

Logre que mi solución quedara mas cortita que la solución :D . . . . . . . . . . . . . . . . .

excercise.js

import { LinkedList } from "./SinglyLinkedList";
import { Node } from "./Node";

export class LinkedListRecharged extends LinkedList {
  get(index) {
    if (index < 0 || index >= this.length) {
      return null
    }
    let i = 0;
    let currentNode = this.head;
    while (index !== i) {
      currentNode = currentNode.next;
      i++;
    }

    return currentNode.value;
  }

  insertAt(index, value) {
    if (index < 0 || index >= this.length) {
      return null
    }

    if (index >= this.length) {

      this.append(newNode);

    }
    const newNode = new Node(value);
    const firstPointer = this.getIndex(index - 1);
    const holdingPointer = firstPointer.next;
    firstPointer.next = newNode;
    newNode.next = holdingPointer;

    this.length++;
  }

  toArray() {
    let currentNode = this.head;
    let i = 0;
    let array = [];
    while (i < this.length) {
      array.push(currentNode.value);
      currentNode = currentNode.next;
      i++;
    }
    return array;
  }

  removeAt(index) {
    if (index < 0 || index >= this.length) {
      return null
    }
    const firstPointer = this.getIndex(index - 1);
    const holdingPointer = this.getIndex(index + 1);
    firstPointer.next = holdingPointer;

    this.length--;
    return this;

  }
  getIndex(index) {
    if (index < 0 || index >= this.length) {
      return null
    }
    let i = 0;
    let currentNode = this.head;
    while (index !== i) {
      currentNode = currentNode.next;
      i++;
    }

    return currentNode;
  }
}

David Ochoa

🛡️🛡️🛡️Escudo anti spoilers🛡️🛡️🛡️

Agrega métodos a singly linked list

!Spoiler Shield

Decidí complicarme la vida y hacerlo con recursividad y closures 😂 a continuación mi solución explicada con comentarios casi en cada línea tratando de que sea lo mas entendible posible

Nunca pares de aprender 🦾

get(index)

get(index) {
  // Si el index es < 0 o > length se levanta un error
  if (index < 0 || index > this.length - 1) {
    return null
  }

  // Variable para almacenar profundiad actual
  let actual = this;

  // Funcion recursiva para subir capas
  function getValue() {
    // Si está en el head el actual es el primer nodo
    if (actual.head) {
      actual = actual.head;
    }
    // Si no está en el head diminuye el index y asigna al siguiente nodo como el actual
    else {
      index = index - 1;
      actual = actual.next;
    }
    // En caso de que el index llegue a 0 se retorna el valor del nodo
    if (index == 0) {
      return actual.value;
    }
    // Se vuelve a llamar la función dentro de la recurrencia
    return getValue();
  }
  // Se llama la funcion desde get(index)
  return getValue();
}

insertAt(index,value)

insertAt(index, value) {
  // Si el index es < 0 o > length se levanta un error
  if (index < 0 || index > this.length - 1) {
    return null
  }

  // Variable para almacenar profundiad actual
  let actual = this;
  // Se aumenta en 1 a la longitud de la lista
  this.length++;
  // Funcion recursiva para subir capas
  function appendValue() {
    // Si está en el head el actual es el primer nodo
    if (actual.head) {
      actual = actual.head;
    }
    // Si no está en el head diminuye el index y asigna al siguiente nodo como el actual
    else {
      index = index - 1;
      actual = actual.next;
    }
    // En caso de que el index llegue a 0 quiere decir que estamos en la posicion a insertar
    if (index == 0) {
      // Se crea una nueva instancia de nodo con el valor a insertar
      let oldNode = new Node(actual.value);
      // Se "COPIA" todo el contenido del nodo en el que estamos a el nodo anterior
      oldNode.next = actual.next;
      // Se reemplaza el nodo actual con el valor que llega por parametro
      actual.value = value;
      // Se reemplaza el siguiente nodo con el nodo creado
      actual.next = oldNode;
      // Se retorna el valor insertado
      return value;
    }
    // Se vuelve a llamar la función dentro de la recurrencia
    return appendValue();
  }
  // Se llama la funcion desde insertAt(index, value)
  return appendValue();
}

toArray()

toArray() {
  // Variable para almacenar profundiad actual y array a retornar
  let actual = this;
  const arr = [];

  // Funcion recursiva para subir capas
  function pushToArray() {
    // Si está en el head el actual es el primer nodo
    if (actual.head) {
      actual = actual.head;
    }
    // Se actual.next es null quiere decir que es la ultima capa
    // Entonces se agrega el ultmo valor y se retorna el arreglo
    if (actual.next == null) {
      arr.push(actual.value);
      return arr;
    }
    // Si no está en el head diminuye el index y asigna al siguiente nodo como el actual
    else {
      arr.push(actual.value);
      actual = actual.next;
    }
    // Se vuelve a llamar la función dentro de la recurrencia
    return pushToArray();
  }
  // Se llama la funcion desde toArray()
  return pushToArray();
}

removeAt(index)

removeAt(index) {
  // Si el index es < 0 o > length se levanta un error
  if (index < 0 || index > this.length - 1) {
    return null
  }

  // Variable para almacenar profundiad actual
  let actual = this;
  // Se disminuye en 1 a la longitud de la lista
  this.length--;
  // Funcion recursiva para subir capas
  function deleteValue() {
    // Si está en el head el actual es el primer nodo
    if (actual.head) {
      actual = actual.head;
    }
    // Si no está en el head diminuye el index y asigna al siguiente nodo como el actual
    else {
      index = index - 1;
      actual = actual.next;
    }
    // En caso de que el index llegue a 0 quiere decir que estamos en la posicion a eliminar
    if (index == 0) {
      // Se crea una nueva instancia de nodo excluyendo el valor a eliminar
      const newNode = new Node(actual.next.value)
      newNode.next = actual.next.next
      actual.value = newNode.value
      actual.next = newNode.next
      // Se retorna el valor eliminado
      return;
    }
    // Se vuelve a llamar la función dentro de la recurrencia
    return deleteValue();
  }
  // Se llama la funcion desde insertAt(index, value)
  return deleteValue();
}

¡Te damos la bienvenida a este reto!

¡Bienvenido al mundo de JavaScript!

Día 1

Variables, funciones y sintaxis básica

Tipos de datos

Playground - Retorna el tipo

Tipos de datos - pt 2

Día 2

Operadores

Hoisting y coerción

Playground - Calcula la propina

Alcance de las variables

Día 3

Condicionales

Playground - Calcula años bisiestos

Switch

Playground - Obten información de mascotas según su tipo

Ciclos

Playground - Dibuja un triangulo

Día 4

Arrays

Playground - Encuentra al michi mas famoso

Objetos

Playground - Obten el promedio de los estudiantes

Día 5 - Checkpoint

Playground - encuentra el palindromo más grande

Día 6

Reasignación y redeclaración

Modo estricto

Día 7

Debugging y manejo de errores

Programación funcional

Día 8

Closures

Playground - Crea una calculadora con closures

Higher order functions

Playground - Crea tu propio método map

Día 9

ECMAScript

TC39

Día 10 - Checkpoint

ES6

ES7

Playground - Task planner

Día 11

Asincronismo

Playground - Promesas

Manejando el asincronismo

Playground - Resuelve el callback hell usando promesas

Playground - Resuelve el callback hell usando async/await

Día 12

Arrays a profundidad

Métodos de arrays: Every, Find y findIndex

Playground - Válida el formulario

Día 13

Métodos de arrays: Includes, Join y concat

Playground - agrupa los productos

Métodos de arrays: Flat y FlatMap

Playground - Encuentra la ubicación del valor buscado

Día 14

Mutable functions

Playground - Modifica una lista de compras

Métodos de arrays: sort

Playground - Ordena los productos

Día 15 - Checkpoint

Playground - Sistema de reservaciones de un hotel

Día 16

Programación orientada a objetos en JavaScript

Objetos literales

Playground - Congela el objeto recursivamente

Día 17

Prototipos en JavaScript

Playground - Modifica el prototype de los arrays

Playground - Crea un auto usando clases

Día 18

Abstracción en JavaScript

Playground - Sistema de carrito de compras

Encapsulamiento en JavaScript

Playground - Encapsula datos de los usuarios

Día 19