Eliminar un nodo desde el final de la lista enlazada

Introducción
       
En este blog, te enseñaré cómo resolver el ejercicio Eliminar un nodo desde el final de la lista enlazada de la plataforma LeetCode en Java, Python, PHP, C++ y JavaScript.

En este artículo, vamos a ver lo siguiente:

✅ Una explicación del problema
✅ Una solución eficiente
✅ Implementaciones en Java, Python, PHP, C++ y JavaScript
                       

Problema
Dada una lista enlazada, elimine el nodo en la posición n contando desde el final, y retorne la lista modificada.

        
        
Pasos para realizar el ejercicio:
1.- Contar la longitud de nodos de la lista. 

Se inicializa tamaño a 0 y aux a el puntero head. Se itera a través de la lista enlazada mientras aux no sea nulo, incrementando en uno la variable tamaño en cada paso.
        
2.- Se comprueban los casos bordes. 

Si la longitud de la lista enlazada es 1, se devuelve null, ya que solo hay un nodo que eliminar. 

Si la longitud de la lista enlazada es igual a n, se devuelve el nodo siguiente a la cabeza, ya que esto significa que se debe eliminar el primer nodo.

3.- Localizar el nodo a eliminar: Se asigna aux a la cabeza de la lista enlazada y se utiliza un bucle hasta llegar a la posición del nodo a eliminar, es decir a el tamaño  - n

4.- Eliminar el nodo de la lista. Se establece el puntero next del nodo que precede al que se va a eliminar para que apunte al nodo dos posiciones adelante, eliminando efectivamente el nodo deseado de la lista enlazada.

5.- Se devuelve la cabeza de la lista enlazada modificada.

Presentación

Código en Java

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
 
        //paso#1
        int tamaño = 0;
        ListNode aux = head;
 
        while (aux != null) {
            aux = aux.next;
            tamaño++;
        }
 
        //paso#2
        if (tamaño == 1) return null;
        if (tamaño == n) return head.next;
 
        //paso#3
        aux = head;
        for (int i = 0; i < tamaño - n - 1; i++) {
            aux = aux.next;
        }
 
        //paso#4
        aux.next = aux.next.next;
 
        //paso#5
        return head;
    }
 
}

Código en php

class Solution {
 
    /**
     * @param ListNode $head
     * @param Integer $n
     * @return ListNode
     */
    function removeNthFromEnd($head, $n) {
        // Paso #1
        $tamaño = 0;
        $aux = $head;
 
        while ($aux !== null) {
            $aux = $aux->next;
            $tamaño++;
        }
 
        // Paso #2
        if ($tamaño == 1) {
            return null;
        }
        if ($tamaño == $n) {
            return $head->next;
        }
 
        // Paso #3
        $aux = $head;
        for ($i = 0; $i < $tamaño - $n - 1; $i++) {
            $aux = $aux->next;
        }
 
        // Paso #4
        $aux->next = $aux->next->next;
 
        // Paso #5
        return $head;
 
    }
}

Código en Python

class Solution(object):
    def removeNthFromEnd(self, head, n):
        # Paso #1
        tamano = 0
        aux = head
 
        while aux is not None:
            aux = aux.next
            tamano += 1
 
        # Paso #2
        if tamano == 1:
            return None
        if tamano == n:
            return head.next
 
        # Paso #3
        aux = head
        for i in range(tamano - n - 1):
            aux = aux.next
 
        # Paso #4
        aux.next = aux.next.next
 
        # Paso #5
        return head

Código en C++

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
 
        // Paso #1
        int size = 0;
        ListNode* aux = head;
 
        while (aux != nullptr) {
            aux = aux->next;
            size++;
        }
 
        // Paso #2
        if (size == 1) return nullptr;
        if (size == n) return head->next;
 
        // Paso #3
        aux = head;
        for (int i = 0; i < size - n - 1; i++) {
            aux = aux->next;
        }
 
        // Paso #4
        aux->next = aux->next->next;
 
        // Paso #5
        return head;
    }
};

Código en JavaScript

var removeNthFromEnd = function(head, n) {
    // Paso #1
        let tamaño = 0;
        let aux = head;
 
        while (aux !== null) {
            aux = aux.next;
            tamaño++;
        }
 
        // Paso #2
        if (tamaño === 1) {
            return null;
        }
        if (tamaño === n) {
            return head.next;
        }
 
        // Paso #3
        aux = head;
        for (let i = 0; i < tamaño - n - 1; i++) {
            aux = aux.next;
        }
 
        // Paso #4
        aux.next = aux.next.next;
 
        // Paso #5
        return head;
};

        
    
Conclusión
En este blog, hemos visto cómo realizar el ejercicio Remove Nth Node From End of List en Java, Python, PHP, C++ y JavaScript.

Hemos visto ejemplos de código en cada lenguaje de programación.