Lista Doblemente Enlazada: Una Estructura de Datos Versátil

En el mundo del desarrollo de software, la manipulación eficiente de datos es esencial para construir aplicaciones robustas y escalables. Entre las muchas estructuras de datos disponibles, la lista doblemente enlazada destaca por su versatilidad y capacidad para manejar operaciones complejas de manera eficiente. En este artículo, exploraremos la implementación y el uso de una lista doblemente enlazada en Java.

Agregar Nodo a la Lista

Agregar un nodo a una lista doblemente enlazada puede hacerse de varias maneras, como al inicio, al final o en una posición específica. A continuación, se muestran los métodos para agregar un nodo en diferentes posiciones de la lista:

Agregar al Final de la Lista

Este método agrega un nuevo nodo al final de la lista. Si la lista está vacía, el nuevo nodo se convierte tanto en la cabeza como en la cola de la lista.

public void agregarAlFinal(int dato) {
    Nodo nuevoNodo = new Nodo(dato);
    if (isEmpty()) {
        head = nuevoNodo;
        tail = nuevoNodo;
    } else {
        tail.siguiente = nuevoNodo;
        nuevoNodo.anterior = tail;
        tail = nuevoNodo;
    }
}

Agregar al Inicio de la Lista

Este método agrega un nuevo nodo al inicio de la lista. Si la lista está vacía, el nuevo nodo se convierte tanto en la cabeza como en la cola de la lista.

public void agregarAlInicio(int dato) {
    Nodo nuevoNodo = new Nodo(dato);
    if (isEmpty()) {
        head = nuevoNodo;
        tail = nuevoNodo;
    } else {
        nuevoNodo.siguiente = head;
        head.anterior = nuevoNodo;
        head = nuevoNodo;
    }
}

Agregar en una Posición Específica

Este método agrega un nuevo nodo en una posición específica de la lista. Si la posición especificada está fuera del rango de la lista, se muestra un mensaje de error.

public void agregarEnPosicion(int dato, int posicion) {
    if (posicion < 0) {
        System.out.println("Posición inválida");
        return;
    }
    if (posicion == 0) {
        agregarAlInicio(dato);
        return;
    }

    Nodo nuevoNodo = new Nodo(dato);
    Nodo iterador = head;
    for (int i = 0; i < posicion - 1; i++) {
        if (iterador == null) {
            System.out.println("Posición fuera de rango");
            return;
        }
        iterador = iterador.siguiente;
    }
    if (iterador == null) {
        System.out.println("Posición fuera de rango");
        return;
    }

    nuevoNodo.siguiente = iterador.siguiente;
    if (iterador.siguiente != null) {
        iterador.siguiente.anterior = nuevoNodo;
    }
    nuevoNodo.anterior = iterador;
    iterador.siguiente = nuevoNodo;
    if (nuevoNodo.siguiente == null) {
        tail = nuevoNodo;
    }
}

Eliminar Nodo de la Lista

Eliminar un nodo de una lista doblemente enlazada implica ajustar correctamente los punteros del nodo anterior y el nodo siguiente al nodo que se va a eliminar. Aquí se muestra el método para eliminar un nodo de la lista:

Eliminar Nodo

Este método elimina un nodo con un dato específico de la lista. Si el nodo a eliminar es el primero o el último de la lista, los punteros de cabeza y cola se actualizan en consecuencia. Si el nodo a eliminar está en el medio de la lista, se ajustan los punteros del nodo anterior y el nodo siguiente.

public void eliminarNodo(int dato) {
    if (isEmpty()) {
        return;
    }

    if (head.dato == dato) {
        head = head.siguiente;
        if (head != null) {
            head.anterior = null;
        } else {
            tail = null;
        }
        return;
    }

    Nodo actual = head;
    while (actual != null && actual.dato != dato) {
        actual = actual.siguiente;
    }

    if (actual == null) {
        System.out.println("El valor no existe dentro de la lista doblemente enlazada");
        return;
    }

    if (actual == tail) {
        tail = tail.anterior;
        tail.siguiente = null;
        return;
    }

    actual.anterior.siguiente = actual.siguiente;
    actual.siguiente.anterior = actual.anterior;
}

Buscar Nodo en la Lista

Buscar un nodo en una lista doblemente enlazada implica recorrer la lista y comparar el dato de cada nodo con el valor buscado. Aquí se muestra el método para buscar un nodo en la lista:

Buscar Nodo

Este método busca un nodo con un dato específico en la lista y devuelve verdadero si se encuentra, o falso si no se encuentra.

public boolean buscar(int dato) {
    Nodo actual = head;
    while (actual != null) {
        if (actual.dato == dato) {
            return true;
        }
        actual = actual.siguiente;
    }
    return false;
}

Aplicaciones en la Vida Real

La lista doblemente enlazada encuentra aplicaciones en una variedad de escenarios del mundo real, como:

• Editores de Texto: Los editores de texto pueden utilizar listas doblemente enlazadas para manejar el historial de edición, permitiendo a los usuarios deshacer y rehacer operaciones de manera eficiente.
• Navegadores Web: Los navegadores web pueden utilizar listas doblemente enlazadas para almacenar el historial de navegación del usuario, lo que facilita la navegación hacia atrás y hacia adelante a través de las páginas visitadas.
• Sistemas de Gestión de Archivos: Los sistemas de gestión de archivos pueden utilizar listas doblemente enlazadas para mantener la estructura de directorios y archivos, permitiendo operaciones de navegación y manipulación eficientes.

Código para la implementación de una lista doblemente enlazada

https://github.com/BranthonyC/EDD_UDV_2024/tree/feature/ListaDoblementeEnlazada