Listas Dobles Sencillas Javascript [SOLUCIONADO]

Listas Dobles Sencillas en JavaScript: Un Enfoque Práctico

El mundo de la programación está lleno de términos, conceptos y patrones que pueden ser abrumadores para los programadores novatos y expertos. Un concepto que a menudo resulta de vital importancia es el de las Listas Dobles Sencillas dentro de JavaScript. Aunque puede parecer un término complicado, es un concepto muy directo y sencillo cuando se entiende.

Definiendo Listas Dobles Sencillas

Las Listas Dobles Sencillas son una estructura de datos que almacena una colección de elementos. Cada uno de estos elementos tiene una referencia al siguiente elemento en la lista, así como una referencia al anterior. Esto permite un fácil desplazamiento a través de la lista.

La creación y manipulación de estas listas en JavaScript se realiza a través de funciones como push, pop, shift y unshift, entre otras. A continuación, se muestra un ejemplo simple de cómo sería.

function Node(data) {
  this.data = data;
  this.next = null;
  this.prev = null;
}
function doubleLinkedList() {
  this._length = 0;
  this.head = null;
  this.tail = null;
}
doubleLinkedList.prototype.add = function(value) {
  var node = new Node(value);
  if (this._length) {
    this.tail.next = node;
    node.prev = this.tail;
    this.tail = node;
  } else {
    this.head = node;
    this.tail = node;
  }
  this._length++;
  return node;
};
doubleLinkedList.prototype.remove = function (pos) {
    var currentNode = this.head,
        length = this._length,
        count = 1,
        message = {failure: 'Error: non-existent node'},
        beforeNodeToDelete = null,
        nodeToDelete = null,
        deletedNode = null;

    // Invalid position
    if (length === 0 || pos < 1 || pos > length) {
        throw new Error(message.failure);
    }
    // The first node is removed
    if (pos === 1) {
        this.head = currentNode.next;

        // There is a second node
        if (!this.head) {
            this.head.prev = null;
        // There's no second node
        } else {
            this.tail = null;
        }
    // Any other node is removed
    } else if (pos === this._length) {
        this.tail = this.tail.prev;
        this.tail.next = null;
    } else {
        while (count++ < pos) {
            currentNode = currentNode.next;
        }

        beforeNodeToDelete = currentNode.prev;
        nodeToDelete = currentNode;
        afterNodeToDelete = currentNode.next;

        beforeNodeToDelete.next = afterNodeToDelete;
        afterNodeToDelete.prev = beforeNodeToDelete;

        deletedNode = nodeToDelete;
        nodeToDelete = null;
    }
    this._length--;

    return message.success;
};

let list = new doubleLinkedList();
list.add('Node 1');
list.add('Node 2');

¿Por qué usar Listas Dobles Sencillas?

JavaScript ofrece una multitud de estructuras de datos para trabajar y es esencial entender cuándo utilizar cada una de ellas. Las listas doblemente enlazadas, o Listas Dobles Sencillas, proporcionan dos ventajas principales: insertar y eliminar nodos de la lista de manera eficiente, y permitir el recorrido en ambas direcciones.

Aunque la programación con JavaScript puede ser desafiante al principio, con el tiempo y la práctica se vuelve más fácil. Entender los conceptos básicos, como las Listas Dobles Sencillas, es fundamental para volverte un programador competente en JavaScript.

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Más información
Privacidad