lista_dinamica_estilofuncional.rs

// --------------------------------------------------
// Definición de un nodo de la lista enlazada
// --------------------------------------------------
#[derive(Debug)]
struct Nodo {
    dato: u32,
    siguiente: Option<Box<Nodo>>, // Enlace al siguiente nodo (o None si es el final)
}

// --------------------------------------------------
// Definición de la lista enlazada
// --------------------------------------------------
#[derive(Debug)]
struct Lista {
    cabeza: Option<Box<Nodo>>, // Puntero al primer nodo de la lista
}

impl Lista {
    /// Crea una lista vacía
    fn nueva() -> Self {
        Lista { cabeza: None }
    }

    /// Inserta un nuevo elemento al inicio de la lista
    fn insertar(&mut self, dato: u32) {
        // Creamos un nuevo Nodo que apunte a la cabeza actual
        let nuevo_nodo = Box::new(Nodo {
            dato,
            siguiente: self.cabeza.take(), // `take()` extrae la Option de la cabeza, dejando None
        });
        // El nuevo nodo pasa a ser la nueva cabeza
        self.cabeza = Some(nuevo_nodo);
    }

    /// Busca si un valor existe en la lista (devuelve true o false)
    fn buscar(&self, dato: u32) -> bool {
        // Función recursiva auxiliar que recorre la sublista
        fn buscar_nodo(n: &Option<Box<Nodo>>, dato: u32) -> bool {
            n.as_ref() // Convierte &Option<Box<Nodo>> en Option<&Box<Nodo>>
                .map_or(false, |nodo| {
                    // Si hay nodo: comparamos o seguimos recursivamente
                    nodo.dato == dato || buscar_nodo(&nodo.siguiente, dato)
                })
        }
        buscar_nodo(&self.cabeza, dato)
    }

    /// Actualiza el primer nodo que tenga el valor `viejo` a `nuevo`. Devuelve true si lo encontró.
    fn actualizar(&mut self, viejo: u32, nuevo: u32) -> bool {
        // Función recursiva auxiliar para actualizar
        fn actualizar_nodo(n: &mut Option<Box<Nodo>>, viejo: u32, nuevo: u32) -> bool {
            match n {
                // Si encontramos el nodo, modificamos su dato
                Some(nodo) if nodo.dato == viejo => {
                    nodo.dato = nuevo;
                    true
                }
                // Si no coincide, seguimos con la siguiente referencia
                Some(nodo) => actualizar_nodo(&mut nodo.siguiente, viejo, nuevo),
                // Llegamos al final sin encontrar nada
                None => false,
            }
        }
        actualizar_nodo(&mut self.cabeza, viejo, nuevo)
    }

    /// Borra el primer nodo cuyo dato coincida con `dato`. Devuelve true si lo eliminó.
    fn borrar(&mut self, dato: u32) -> bool {
        // Auxiliar recursivo que realiza el borrado
        fn borrar_nodo(n: &mut Option<Box<Nodo>>, dato: u32) -> bool {
            match n {
                // Si el nodo actual coincide, lo saltamos enlazando al siguiente
                Some(nodo) if nodo.dato == dato => {
                    *n = nodo.siguiente.take();
                    true
                }
                // Si no coincide, seguimos recursivamente
                Some(nodo) => borrar_nodo(&mut nodo.siguiente, dato),
                // Nada que borrar al llegar al final
                None => false,
            }
        }
        borrar_nodo(&mut self.cabeza, dato)
    }

    /// Imprime todos los elementos de la lista de manera visual
    fn imprimir(&self) {
        // Función recursiva auxiliar para impresión
        fn imprimir_nodo(n: &Option<Box<Nodo>>) {
            if let Some(nodo) = n {
                print!("{} -> ", nodo.dato);
                imprimir_nodo(&nodo.siguiente);
            } else {
                // Cuando llegamos a None, marcamos el final
                println!("None");
            }
        }
        imprimir_nodo(&self.cabeza);
    }
}

fn main() {
    // Creamos la lista y agregamos tres elementos
    let mut lista = Lista::nueva();
    lista.insertar(10);
    lista.insertar(20);
    lista.insertar(30);

    println!("Lista después de inserciones:");
    lista.imprimir(); // Debe mostrar: 30 -> 20 -> 10 -> None

    // Probamos búsqueda
    println!("¿Existe 20? {}", lista.buscar(20)); // true
    println!("¿Existe 40? {}", lista.buscar(40)); // false

    // Probamos actualización
    if lista.actualizar(20, 25) {
        println!("Elemento 20 actualizado a 25");
    } else {
        println!("Elemento 20 no encontrado para actualizar");
    }
    lista.imprimir(); // 30 -> 25 -> 10 -> None

    // Probamos borrado en diferentes casos
    for clave in [25, 30, 10] {
        if lista.borrar(clave) {
            println!("Elemento {} borrado", clave);
        } else {
            println!("Elemento {} no encontrado para borrar", clave);
        }
        lista.imprimir();
    }
}