Estoy trabajando en este problema de leetcode: https://leetcode.com/problems/delete-node-in-a-linked-list/
Escriba una función para eliminar un nodo en una lista de enlace simple. No se le dará acceso al encabezado de la lista, sino que se le dará acceso al nodo que se eliminará directamente.
Se garantiza que el nodo a eliminar no es un nodo final en la lista.
y he encontrado esta solución:
var deleteNode = function (node) { node.val = node.next.val; node.next = node.next.next; };Esta es mi implementación de lista enlazada:
class Node { constructor(value) { this.value = value; this.next = null; } } class LinkedList { constructor(value) { const newNode = new Node(value); this.head = newNode; this.tail = this.head; this.length = 1; } }No sé por qué no funciona en mi implementación de LL.
En la pregunta a la que se hace referencia, solo se usa esta clase de nodo. Esto es lo que muestra Leet Code en un bloque de comentarios:
/** * Definition for singly-linked list. * function ListNode(val, next) { * this.val = (val===undefined ? 0 : val) * this.next = (next===undefined ? null : next) * } */ El primer problema es que la propiedad val se llama value en su clase, por lo que debe cambiar ese nombre donde aparece en el código deleteNode .
En segundo lugar, Leet Code no introduce ni necesita una clase de lista enlazada, lo que significa que todos los datos que tiene en su instancia de LinkedList deberán mantenerse actualizados además de lo que haría con solo una clase de nodo, como la que arriba.
En realidad, al agregar una clase LinkedList con sus propias propiedades, tendrá un problema adicional: cuando se deleteNode(node) , deberá asegurarse de que el node sea realmente un nodo en su instancia de lista vinculada, y no en alguna otra lista enlazada. ¿Qué pasa si tienes dos listas enlazadas? ¿Cómo sabrá a qué lista pertenece el nodo que se pasa como argumento a deleteNode ?
Ahora, si podemos suponer que el argumento del node es un nodo en su lista enlazada actual, podemos definir deleteNode como un método.
Una nota al margen: su constructor LinkedList crea inmediatamente un nodo, pero esta es una mala idea: las listas vinculadas pueden estar vacías, así que comience con una lista vacía (de forma predeterminada) y use los métodos de adición habituales para agregar también la primera nodo.
class Node { constructor(value) { this.value = value; this.next = null; } } class LinkedList { constructor() { // A linked list could be empty, so don't create a node this.head = null; this.tail = null; this.length = 0; } append(val) { // if (!this.tail) this.head = this.tail = new Node(val); else this.tail = this.tail.next = new Node(val); this.length++; } deleteNode(node) { node.value = node.next.value; // Use value, not val node.next = node.next.next; // Also update the linked list properties: if (!node.next) this.tail = node; this.length--; } *[Symbol.iterator]() { // A generator to easily output the list's values for (let node = this.head; node; node = node.next) { yield node.value; } } } // demo const list = new LinkedList(); list.append(1); list.append(2); list.append(3); console.log("initial list: ", ...list); list.deleteNode(list.head.next); // Delete the 2 console.log("after deletion:", ...list);