Lista enlazada

class Nodo:
    def __init__(self, valor):
        self.valor = valor
        self.siguiente = None


class Lista:
    """Lista simplemente enlazada con referencia al primero y al último."""
    def __init__(self):
        self.cabeza = self.ultimo = None
        self.tam = 0

    def al_principio(self, x):                  # O(1)
        n = Nodo(x)
        n.siguiente = self.cabeza
        self.cabeza = n
        if self.ultimo is None:
            self.ultimo = n
        self.tam += 1

    def al_final(self, x):                      # O(1) gracias a la referencia al último
        n = Nodo(x)
        if self.ultimo is None:
            self.cabeza = n
        else:
            self.ultimo.siguiente = n
        self.ultimo = n
        self.tam += 1

    def borrar(self, x):                        # O(n): hay que encontrar al anterior
        anterior, p = None, self.cabeza
        while p is not None and p.valor != x:
            anterior, p = p, p.siguiente
        if p is None:
            return False
        if anterior is None:
            self.cabeza = p.siguiente           # era el primero
        else:
            anterior.siguiente = p.siguiente    # el anterior se salta a p
        if p is self.ultimo:
            self.ultimo = anterior
        self.tam -= 1
        return True

    def __str__(self):
        valores, p = [], self.cabeza
        while p:
            valores.append(str(p.valor))
            p = p.siguiente
        return "[" + " → ".join(valores) + f"] ({self.tam} {'nodo' if self.tam == 1 else 'nodos'})"


l = Lista()
l.al_final(3)
l.al_final(7)
l.al_principio(1)
l.al_final(9)
print(l)
l.borrar(7)
print("Tras borrar el 7:", l)
l.borrar(1)
l.borrar(9)
print("Tras borrar el 1 y el 9:", l)

class Nodo {
    constructor(valor) {
        this.valor = valor;
        this.siguiente = null;
    }
}

/** Lista simplemente enlazada con referencia al primero y al último. */
class Lista {
    cabeza = null;
    ultimo = null;
    tam = 0;

    alPrincipio(x) {                          // O(1)
        const n = new Nodo(x);
        n.siguiente = this.cabeza;
        this.cabeza = n;
        if (this.ultimo === null) this.ultimo = n;
        this.tam++;
    }

    alFinal(x) {                              // O(1) gracias a la referencia al último
        const n = new Nodo(x);
        if (this.ultimo === null) this.cabeza = n;
        else this.ultimo.siguiente = n;
        this.ultimo = n;
        this.tam++;
    }

    borrar(x) {                               // O(n): hay que encontrar al anterior
        let anterior = null, p = this.cabeza;
        while (p !== null && p.valor !== x) { anterior = p; p = p.siguiente; }
        if (p === null) return false;
        if (anterior === null) this.cabeza = p.siguiente;   // era el primero
        else anterior.siguiente = p.siguiente;              // el anterior se salta a p
        if (p === this.ultimo) this.ultimo = anterior;
        this.tam--;
        return true;
    }

    toString() {
        const v = [];
        for (let p = this.cabeza; p !== null; p = p.siguiente) v.push(p.valor);
        return `[${v.join(" → ")}] (${this.tam} ${this.tam === 1 ? "nodo" : "nodos"})`;
    }
}

const l = new Lista();
l.alFinal(3);
l.alFinal(7);
l.alPrincipio(1);
l.alFinal(9);
console.log(String(l));
l.borrar(7);
console.log("Tras borrar el 7: " + l);
l.borrar(1);
l.borrar(9);
console.log("Tras borrar el 1 y el 9: " + l);

using System;
using System.Collections.Generic;

class Nodo {
    public int Valor;
    public Nodo? Siguiente;
    public Nodo(int valor) { Valor = valor; }
}

// Lista simplemente enlazada con referencia al primero y al último.
class Lista {
    private Nodo? cabeza, ultimo;
    private int tam = 0;

    public void AlPrincipio(int x) {               // O(1)
        var n = new Nodo(x) { Siguiente = cabeza };
        cabeza = n;
        ultimo ??= n;
        tam++;
    }

    public void AlFinal(int x) {                   // O(1) gracias a la referencia al último
        var n = new Nodo(x);
        if (ultimo == null) cabeza = n;
        else ultimo.Siguiente = n;
        ultimo = n;
        tam++;
    }

    public bool Borrar(int x) {                    // O(n): hay que encontrar al anterior
        Nodo? anterior = null, p = cabeza;
        while (p != null && p.Valor != x) { anterior = p; p = p.Siguiente; }
        if (p == null) return false;
        if (anterior == null) cabeza = p.Siguiente;    // era el primero
        else anterior.Siguiente = p.Siguiente;         // el anterior se salta a p
        if (p == ultimo) ultimo = anterior;
        tam--;
        return true;
    }

    public override string ToString() {
        var v = new List<int>();
        for (var p = cabeza; p != null; p = p.Siguiente) v.Add(p.Valor);
        return 
quot;[{string.Join(" → ", v)}] ({tam} {(tam == 1 ? "nodo" : "nodos")})";
    }
}

class Program {
    static void Main() {
        var l = new Lista();
        l.AlFinal(3);
        l.AlFinal(7);
        l.AlPrincipio(1);
        l.AlFinal(9);
        Console.WriteLine(l);
        l.Borrar(7);
        Console.WriteLine("Tras borrar el 7: " + l);
        l.Borrar(1);
        l.Borrar(9);
        Console.WriteLine("Tras borrar el 1 y el 9: " + l);
    }
}

<?php
class Nodo {
    public ?Nodo $siguiente = null;
    public function __construct(public int $valor) { }
}

/** Lista simplemente enlazada con referencia al primero y al último. */
class Lista {
    private ?Nodo $cabeza = null;
    private ?Nodo $ultimo = null;
    private int $tam = 0;

    public function alPrincipio(int $x): void {          // O(1)
        $n = new Nodo($x);
        $n->siguiente = $this->cabeza;
        $this->cabeza = $n;
        $this->ultimo ??= $n;
        $this->tam++;
    }

    public function alFinal(int $x): void {              // O(1) gracias a la referencia al último
        $n = new Nodo($x);
        if ($this->ultimo === null) $this->cabeza = $n;
        else $this->ultimo->siguiente = $n;
        $this->ultimo = $n;
        $this->tam++;
    }

    public function borrar(int $x): bool {               // O(n): hay que encontrar al anterior
        $anterior = null;
        $p = $this->cabeza;
        while ($p !== null && $p->valor !== $x) { $anterior = $p; $p = $p->siguiente; }
        if ($p === null) return false;
        if ($anterior === null) $this->cabeza = $p->siguiente;   // era el primero
        else $anterior->siguiente = $p->siguiente;               // el anterior se salta a $p
        if ($p === $this->ultimo) $this->ultimo = $anterior;
        $this->tam--;
        return true;
    }

    public function __toString(): string {
        $v = [];
        for ($p = $this->cabeza; $p !== null; $p = $p->siguiente) $v[] = $p->valor;
        return "[" . implode(" → ", $v) . "] ({$this->tam} " . ($this->tam === 1 ? "nodo" : "nodos") . ")";
    }
}

$l = new Lista();
$l->alFinal(3);
$l->alFinal(7);
$l->alPrincipio(1);
$l->alFinal(9);
echo $l, "\n";
$l->borrar(7);
echo "Tras borrar el 7: $l\n";
$l->borrar(1);
$l->borrar(9);
echo "Tras borrar el 1 y el 9: $l\n";

def invertir(cabeza):
    """Invierte la lista sin crear nodos nuevos: se le da la vuelta a cada flecha."""
    anterior, actual = None, cabeza
    while actual is not None:
        siguiente = actual.siguiente        # se guarda antes de perderlo
        actual.siguiente = anterior         # la flecha apunta hacia atrás
        anterior, actual = actual, siguiente
    return anterior                         # el que era el último es la nueva cabeza

/** Invierte la lista sin crear nodos nuevos: se le da la vuelta a cada flecha. */
function invertir(cabeza) {
    let anterior = null, actual = cabeza;
    while (actual !== null) {
        const siguiente = actual.siguiente;   // se guarda antes de perderlo
        actual.siguiente = anterior;          // la flecha apunta hacia atrás
        anterior = actual;
        actual = siguiente;
    }
    return anterior;                          // el que era el último es la nueva cabeza
}

// Invierte la lista sin crear nodos nuevos: se le da la vuelta a cada flecha.
static Nodo? Invertir(Nodo? cabeza) {
    Nodo? anterior = null, actual = cabeza;
    while (actual != null) {
        Nodo? siguiente = actual.Siguiente;   // se guarda antes de perderlo
        actual.Siguiente = anterior;          // la flecha apunta hacia atrás
        anterior = actual;
        actual = siguiente;
    }
    return anterior;                          // el que era el último es la nueva cabeza
}

/** Invierte la lista sin crear nodos nuevos: se le da la vuelta a cada flecha. */
function invertir(?Nodo $cabeza): ?Nodo {
    $anterior = null;
    $actual = $cabeza;
    while ($actual !== null) {
        $siguiente = $actual->siguiente;      // se guarda antes de perderlo
        $actual->siguiente = $anterior;       // la flecha apunta hacia atrás
        $anterior = $actual;
        $actual = $siguiente;
    }
    return $anterior;                         // el que era el último es la nueva cabeza
}