Métodos para Manipular Nodos en Listas Enlazadas

Curso de Estructuras de Datos con JavaScript

Contenido del curso

Introducción a las estructuras de datos

Arrays y strings

Hash Table

Linked List

Stacks

Queues

Trees

20
Estructuras de Datos: Árboles Binarios y Búsqueda en JavaScript
06:15 min
21
Construcción y validación de un Árbol de Búsqueda Binaria en JavaScript
19:36 min

Graphs

Cierre

25
Estructuras de Datos con JavaScript: Práctica y Aplicación
03:14 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0012:12

Métodos para Manipular Nodos en Listas Enlazadas

Curso de Estructuras de Datos con JavaScript

Clase 13 de 25

Clase 13 / 25

Recursos

Domina la lógica de una linked list al implementar los métodos append y prepend para agregar nodos al final y al inicio. Conecta correctamente la cabeza, la cola y el puntero next para que la estructura crezca sin errores y valida la longitud paso a paso con pruebas simples.

¿Cómo agregar nodos al final con append?

Para que un nuevo nodo sea la nueva cola, la secuencia es directa: crear el nodo, enlazarlo con el tail.next y actualizar la cola. Así logras que el null final se reemplace por el nuevo nodo y la lista crezca de forma consistente.

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

class LinkedList {
  constructor(initialValue) {
    const firstNode = new Node(initialValue);
    this.head = firstNode;
    this.tail = firstNode;
    this.length = 1;
  }

  append(value) {
    const newNode = new Node(value);
    this.tail.next = newNode; // enlaza el último nodo actual con el nuevo
    this.tail = newNode;      // el nuevo nodo se convierte en la cola
    this.length++;
    return this;
  }
}

¿Cuál es la lógica de tail.next y cola?

Crear el nuevo nodo con el value que recibes.
Asignar tail.next al nuevo nodo para colocarlo al final.
Actualizar tail al nuevo nodo para que sea la cola.
Incrementar length para reflejar el nuevo tamaño.

¿Cómo validar la estructura y la longitud?

Verificar que la estructura existe con una longitud inicial de uno.
Ejecutar append(2): la cabeza sigue siendo 1, la cola ahora es 2.
Ejecutar append(3): la cola ahora es 3 y la cabeza permanece en 1.
Observar el anidado: cada nodo tiene value y un next que apunta al siguiente o a null al final.

¿Cómo insertar al inicio con prepend?

Para agregar un nodo como nueva cabeza, primero lo conectas al inicio y luego actualizas la referencia de la cabeza. La clave: apuntar el newNode.next al head actual y después mover la cabeza al newNode.

class LinkedList {
  // ... mismo constructor y Node que arriba

  prepend(value) {
    const newNode = new Node(value);
    newNode.next = this.head; // conecta el nuevo nodo con la cabeza actual
    this.head = newNode;      // el nuevo nodo se convierte en la cabeza
    this.length++;
    return this;
  }
}

¿Qué cambia en la cabeza y los pointers?

El nuevo nodo apunta con next a la cabeza anterior.
La referencia head pasa a ser el nuevo nodo.
La cola no cambia si la lista ya tenía más de un nodo.
La longitud aumenta en uno.

¿Qué se observa al probar con cero como nueva cabeza?

Ejecutar prepend(0): la cabeza ahora es 0.
La cola se mantiene en 1 si la lista era [1] antes.
La longitud refleja el cambio: pasa a 2 tras el prepend.

¿Qué habilidades y keywords refuerzas con esta práctica?

Comprendes cómo modelar una linked list con una clase que mantiene referencias a head, tail y length, y cómo un nodo encapsula value y next. Practicas el manejo de pointers para insertar correctamente sin romper la estructura. Además, validas el estado tras cada operación con retornos tipo return this y pruebas en el navegador.

Diseño de métodos: append para el final y prepend para el inicio.
Manipulación de referencias: head, tail, next y su actualización ordenada.
Pensamiento visual: crear un mapa mental de cómo cambia el null al enlazar un nuevo nodo.
Verificación incremental: revisar longitud y anidado tras cada operación.
Preparación para el reto: método insert para colocar un nodo en medio, pensando primero la lógica en papel.

Si ya implementaste tu método, comparte tu solución y explica cómo llegaste a ella: así todos aprendemos más rápido.

Fernando Quinteros Gutierrez

Hace 6 años

🗒 Aporte para la clase

Algo que me ayudo bastante a la hora de entender esta clase fue que estamos jugando bastante con la referencia de JavaScript. Recuerda mantener la idea de que no estamos guardando los valores de los objetos en sí, si no el lugar [referencia] de donde se encuentran en el memory heap.

El memory Heap es donde se guardan todos los objetos, debido a que los objetos necesitan una mayor cantidad de memoria a diferencia que los números, cadenas o boleanos, la desventaja es que el memory heap es lento por lo cual se necesita dar una ubicación de donde se está guardado. Si deseas saber más acerca de este tema puedes revisar este video creado por el profesor del curso de fundamentos de javascript

😉 Mi explicación del código según a lo que entendí

class MySinglyLinkedList {
  constructor(value) {
    // creamos el inicio de nuestro SinglyLinkedList
    this.head = {
      value,
      next: null,
    };

    // Aqui sucede la magia ✨
    // Todo lo que modifiquemos en los atributos de tail
    // se modificará en la estructura inicial
    // por la RERENCIA!
    this.tail = this.head;

    this.length = 1;
  }

  append(value) {
    // aquí estamos creando un nuevo nodo
    const newNode = new Node(value);

    // Como mencionamos anteriormente
    // si modificamos la cola por la REFERENCIA
    // se modificará la estructura inicial! 🖊
    this.tail.next = newNode;
    // Pero aun tail sigue apuntando a la CABEZA
    // de la estructura inicial entonces es momento
    // de apuntar al nuevo nodo creado para que posteriormente
    // podamos agregar más nodos! 🚀
    this.tail = newNode;
    // Finalmente aumentamos el tamaño definido de
    // nuestra estructura 👨‍🔧
    this.length++;

    return this;
  }

💚 Cualquier correción o comentario es bienvenido!

Rogelio Samuel Moreno Corrales

Hace 6 años

Gracias, tu aporte me ayudó a entenderlo, luego hice mis propios apuntes, explicado a como entendí, por si les interesa, si hay algún error diganme por favor :)

class ListNode {
	constructor(value) {
		this.value = value;
		this.next = null;
	}
}

class SinglyLinkedList {
	constructor(value) {
		this.head = {
			value: value,
			next: null,
		};
		//tail y head apuntan a la misma direccion de memoria
		// y si cambia UNA PROPIEDAD de uno, cambiará en el otro
		this.tail = this.head;
		this.length = 1;
	}
	//insertar al final
	//Esto funciona ya que en el contructor hay una referencia
	//cambiamos UNA PROPIEDAD del tail entonces también cambia en el head
	append(value) {
		const newNode = new ListNode(value); //creamos nueva referencia
		this.tail.next = newNode; //el next del head y el next del tail es el mismo
		this.tail = newNode; //tail y el next de head tienen la misma referencia
		this.length++;
		return this;
		/*
		Entonces ahora tail y ese nodo que se agregó
		el next del head es el next de ese nodo que se agregó
		Ambos next estan referenciados, COMO AL INICIO
		entonces cuando creemos otro nodo simplemente se repetirá el proceso
		*/
	}
}

let singlyLinkedList = new SinglyLinkedList(1);

Nicolas Castañeda

Hace 6 años

Primero muchismas gracias me ayudo un monton a entender porque se cambiaba el next del head porque la verdad andaba enrredado y segundo: Rogelio, mas que el que cambiar el head y el tail es mas como si head y tail son el valor de una casilla entonces al igualarlo estos dos valores realmente son la misma casilla, por lo cual el modificar el uno o el otro realmente lo que haces es modificar lo que hay dentro de esa casilla, ya que no son objetos diferentes. No se si lo entendiste asi, pero me parecio que depronto era un poco mas claro verlo asi con casillas de cajas y cajas '^^

Comentarios (97)97 comentarios

Rony Porraz Vargas

David Cruz Portilla

Christian Velázquez

Omar Flores Grimontt

Josué Eduardo Apén Bal

Hace 5 años

Luis Berenguer

Jorge Cruz Perez

Jimmy Buriticá Londoño

Carlos Eduardo Gomez García

Juan Sebastián Agudelo

Andres Velasquez

Agustina Corvo

Gabriel Rodriguez

Tomas Di Mauro

Melisa Barrera

Hace 2 años

giovanni.sayago

Karen Benites Segura

Hace un año

Miguel Enrique Velásquez Millán

Rigoberto Maldonado

Robinson Matias Aguilar Bascuñan

Freddy J Marin L

Hace 4 años

Karen Paola Torres Archbold

Jefred Bedoya

Hace 6 meses

Isaías Chávez Martínez

Kyb3r Cipher

Ana Rotela Cabrera

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

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

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

Métodos para Manipular Nodos en Listas Enlazadas