Remove Nth node from end of the Linked List

Given a linked list. The task is to remove the Nth node from the end of the linked list.

Examples:

Input : 1->2->3->4->5 , N = 2 
Output : 1->2->3->5

Input : 7->8->4->3->2 , N = 1 
Output : 7->8->4->3  

Prerequisites:
1. Delete a node from the linked list. 
2. Find the nth node from the end of the linked list
Approach: 
Deleting the Bth node from last is basically the same as deleting (length-B+1) from the start. In our approach, first, we evaluate the length of the linked list, then check 

• If length < B, then we can’t remove the node
• If length = B, then return head->next
• If length > B, then it means we have to delete the intermediate node, we will delete this node and make its prev node point to the next node of the deleted node. 
  

C++

// CPP program to delete nth node from last
#include <bits/stdc++.h>
using namespace std;

// Structure of node
struct Node {
    int data;
    struct Node* next;
};

// Function to insert node in a linked list
struct Node* create(struct Node* head, int x)
{
    struct Node *temp, *ptr = head;
    temp = new Node();
    temp->data = x;
    temp->next = NULL;
    if (head == NULL)
        head = temp;
    else {
        while (ptr->next != NULL) {
            ptr = ptr->next;
        }
        ptr->next = temp;
    }
    return head;
}

// Function to remove nth node from last
Node* removeNthFromEnd(Node* head, int B)
{
    // To store length of the linked list
    int len = 0;
    Node* tmp = head;
    while (tmp != NULL) {
        len++;
        tmp = tmp->next;
    }

    // B > length, then we can't remove node
    if (B > len)
    {
        cout << "Length of the linked list is " << len;
        cout  << " we can't remove "<< B << "th node from the";
        cout << " linked list\n";
        return head;
    }

    // We need to remove head node
    else if (B == len) {

        // Return head->next
        return head->next;

    }
    else
    {
        // Remove len - B th node from starting
        int diff = len - B;
        Node* prev= NULL;
        Node* curr = head;
        for(int i = 0;i < diff;i++){
            prev = curr;
            curr = curr->next;
        }
        prev->next = curr->next;
        return head;
    }

}

// This function prints contents of linked
// list starting from the given node
void display(struct Node* head)
{

    struct Node* temp = head;
    while (temp != NULL) {
        cout << temp->data << " ";
        temp = temp->next;
    }
    cout << endl;
}

// Driver code
int main()
{
    struct Node* head = NULL;


    head = create(head, 1);
    head = create(head, 2);
    head = create(head, 3);
    head = create(head, 4);
    head = create(head, 5);

    int n = 2;

    cout << "Linked list before modification: \n";
    display(head);

    head = removeNthFromEnd(head, 2);
    cout << "Linked list after modification: \n";
    display(head);

    return 0;
}

C

// C program to delete nth node from last
#include<stdio.h>
#include<stdlib.h>
// Structure of node
struct Node {
    int data;
    struct Node* next;
};

// Function to insert node in a linked list
struct Node* create(struct Node* head, int x)
{
    struct Node *temp, *ptr = head;
    temp = (struct Node*)malloc(sizeof(struct Node));
    temp->data = x;
    temp->next = NULL;
    if (head == NULL)
        head = temp;
    else {
        while (ptr->next != NULL) {
            ptr = ptr->next;
        }
        ptr->next = temp;
    }
    return head;
}

// Function to remove nth node from last
struct Node* removeNthFromEnd(struct Node* head, int B)
{
    // To store length of the linked list
    int len = 0;
    struct Node* tmp = head;
    while (tmp != NULL) {
        len++;
        tmp = tmp->next;
    }

    // B > length, then we can't remove node
    if (B > len)
    {
        printf( "Length of the linked list is  %d",len );
        printf( " we can't remove %dth node from the",B);
        printf(" linked list\n");
        return head;
    }

    // We need to remove head node
    else if (B == len) {

        // Return head->next
        return head->next;

    }
    else
    {
        // Remove len - B th node from starting
        int diff = len - B;
        struct Node* prev= NULL;
        struct Node* curr = head;
        for(int i = 0;i < diff;i++){
            prev = curr;
            curr = curr->next;
        }
        prev->next = curr->next;
        return head;
    }

}

// This function prints contents of linked
// list starting from the given node
void display(struct Node* head)
{

    struct Node* temp = head;
    while (temp != NULL) {
        printf("%d  ",temp->data);
        temp = temp->next;
    }
    printf("\n");
}

// Driver code
int main()
{
    struct Node* head = NULL;


    head = create(head, 1);
    head = create(head, 2);
    head = create(head, 3);
    head = create(head, 4);
    head = create(head, 5);

    int n = 2;

    printf("Linked list before modification: \n");
    display(head);

    head = removeNthFromEnd(head, 2);
    printf("Linked list after modification: \n");
    display(head);

    return 0;
}

Java

// Java program to delete nth node from last
class GFG
{

// Structure of node
static class Node
{
    int data;
    Node next;
};

// Function to insert node in a linked list
static Node create(Node head, int x)
{
    Node temp, ptr = head;
    temp = new Node();
    temp.data = x;
    temp.next = null;
    if (head == null)
        head = temp;
    else
    {
        while (ptr.next != null)
        {
            ptr = ptr.next;
        }
        ptr.next = temp;
    }
    return head;
}

// Function to remove nth node from last
static Node removeNthFromEnd(Node head, int B)
{
    // To store length of the linked list
    int len = 0;
    Node tmp = head;
    while (tmp != null)
    {
        len++;
        tmp = tmp.next;
    }

    // B > length, then we can't remove node
    if (B > len)
    {
        System.out.print("Length of the linked list is " + len);
        System.out.print(" we can't remove "+ B +
                         "th node from the");
        System.out.print(" linked list\n");
        return head;
    }

    // We need to remove head node
    else if (B == len)
    {

        // Return head.next
        return head.next;

    }
    else
    {
        // Remove len - B th node from starting
        int diff = len - B;
        Node prev= null;
        Node curr = head;
        for(int i = 0; i < diff; i++)
        {
            prev = curr;
            curr = curr.next;
        }
        prev.next = curr.next;
        return head;
    }

}

// This function prints contents of linked
// list starting from the given node
static void display(Node head)
{
    Node temp = head;
    while (temp != null)
    {
        System.out.print(temp.data + " ");
        temp = temp.next;
    }
    System.out.println();
}

// Driver code
public static void main(String[] args)
{
    Node head = null;

    head = create(head, 1);
    head = create(head, 2);
    head = create(head, 3);
    head = create(head, 4);
    head = create(head, 5);

    int n = 2;

    System.out.print("Linked list before modification: \n");
    display(head);

    head = removeNthFromEnd(head, 2);
    System.out.print("Linked list after modification: \n");
    display(head);
}
}

// This code is contributed by Rajput-Ji

Python3

# Python3 program to delete nth node from last
class Node:

    # Function to initialise the node object
    def __init__(self, data):
        self.data = data # Assign data
        self.next = None # Initialize next as null

class LinkedList:

    # Function to initialize head
    def __init__(self):
        self.head = None

    # Function to add node at the end
    def create(self, x):

        new_node = Node(x)

        if self.head is None:
            self.head = new_node
            return

        last = self.head
        while last.next:
            last = last.next

        last.next = new_node

    # This function prints contents of linked
    # list starting from the given node
    def display(self):
        temp = self.head

        while temp:
            print(temp.data, end = " ")
            temp = temp.next

# Function to remove nth node from last
def removeNthFromEnd(head, k):

    # the function uses two pointer method
    first = head
    second = head
    count = 1
    while count <= k:
        second = second.next
        count += 1
    if second is None:
        head.value = head.next.value
        head.next = head.next.next
        return
    while second.next is not None:
        first = first.next
        second = second.next
    first.next = first.next.next

# Driver code

# val list contains list of values
val = [1, 2, 3, 4, 5]
k = 2
ll = LinkedList()
for i in val:
    ll.create(i)

print("Linked list before modification:");
ll.display()

removeNthFromEnd(ll.head, k)

print("\nLinked list after modification:");
ll.display()

# This code is contributed by Dhinesh

C#

// C# program to delete nth node from last
using System;

class GFG
{

// Structure of node
class Node
{
    public int data;
    public Node next;
};

// Function to insert node in a linked list
static Node create(Node head, int x)
{
    Node temp, ptr = head;
    temp = new Node();
    temp.data = x;
    temp.next = null;
    if (head == null)
        head = temp;
    else
    {
        while (ptr.next != null)
        {
            ptr = ptr.next;
        }
        ptr.next = temp;
    }
    return head;
}

// Function to remove nth node from last
static Node removeNthFromEnd(Node head, int B)
{
    // To store length of the linked list
    int len = 0;
    Node tmp = head;
    while (tmp != null)
    {
        len++;
        tmp = tmp.next;
    }

    // B > length, then we can't remove node
    if (B > len)
    {
        Console.Write("Length of the linked list is " + len);
        Console.Write(" we can't remove " + B +
                           "th node from the");
        Console.Write(" linked list\n");
        return head;
    }

    // We need to remove head node
    else if (B == len)
    {

        // Return head.next
        return head.next;

    }
    else
    {
        // Remove len - B th node from starting
        int diff = len - B;
        Node prev= null;
        Node curr = head;
        for(int i = 0; i < diff; i++)
        {
            prev = curr;
            curr = curr.next;
        }
        prev.next = curr.next;
        return head;
    }

}

// This function prints contents of linked
// list starting from the given node
static void display(Node head)
{
    Node temp = head;
    while (temp != null)
    {
        Console.Write(temp.data + " ");
        temp = temp.next;
    }
    Console.Write("\n");
}

// Driver code
public static void Main(String[] args)
{
    Node head = null;

    head = create(head, 1);
    head = create(head, 2);
    head = create(head, 3);
    head = create(head, 4);
    head = create(head, 5);

    Console.Write("Linked list before modification: \n");
    display(head);

    head = removeNthFromEnd(head, 2);
    Console.Write("Linked list after modification: \n");
    display(head);
}
}

// This code is contributed by 29AjayKumar

Javascript

<script>
// javascript program to delete nth node from last    // Structure of node
    class Node {
        constructor() {
            this.data = 0;
            this.next = null;
        }
    }
    // Function to insert node in a linked list
    function create(head , x) {
        var temp, ptr = head;
        temp = new Node();
        temp.data = x;
        temp.next = null;
        if (head == null)
            head = temp;
        else {
            while (ptr.next != null) {
                ptr = ptr.next;
            }
            ptr.next = temp;
        }
        return head;
    }

    // Function to remove nth node from last
    function removeNthFromEnd(head , B) {
        // To store length of the linked list
        var len = 0;
        var tmp = head;
        while (tmp != null) {
            len++;
            tmp = tmp.next;
        }

        // B > length, then we can't remove node
        if (B > len) {
            document.write("Length of the linked list is " + len);
            document.write(" we can't remove " + B + "th node from the");
            document.write(" linked list\n");
            return head;
        }

        // We need to remove head node
        else if (B == len) {

            // Return head.next
            return head.next;

        }
        else {
            // Remove len - B th node from starting
            var diff = len - B;
            var prev = null;
            var curr = head;
            for (i = 0; i < diff; i++) {
                prev = curr;
                curr = curr.next;
            }
            prev.next = curr.next;
            return head;
        }

    }

    // This function prints contents of linked
    // list starting from the given node
    function display(head) {
        var temp = head;
        while (temp != null) {
            document.write(temp.data + " ");
            temp = temp.next;
        }
        document.write("<br/>");
    }

    // Driver code

        var head = null;

        head = create(head, 1);
        head = create(head, 2);
        head = create(head, 3);
        head = create(head, 4);
        head = create(head, 5);

        var n = 2;

        document.write("Linked list before modification: <br/>");
        display(head);

        head = removeNthFromEnd(head, 2);
        document.write("Linked list after modification: <br/>");
        display(head);

// This code contributed by Rajput-Ji
</script>

Output

Linked list before modification: 
1  2  3  4  5  
Linked list after modification: 
1  2  3  5  

Time Complexity: O(N)

Auxiliary Space: O(N)

Another Approach: 

Two Pointer Approach
Deleting the Bth node from last is basically the same as deleting (length-B+1) from the start. In our approach, we will define 2 pointers, fast pointer and slow pointer.
Algorithm: 

1. Take two Node slowPtr and fastPtr, such that next points to the head
2. Take one Node to store the head, initially it’s a dummy node(start), and the next of the node will be pointing to the head. The dummy node is taken to handle the edge case where B=N(size of the LinkedList)
3. Start traversing until the fast pointer reaches the nth node
4. Start traversing by one step both of the pointers until the fast pointers reach the end
5. When the traversal is done, delete the next node to slowPtr
6. Return the next of start

C++

// CPP program to delete nth node from last
#include <bits/stdc++.h>
using namespace std;

// Structure of node
struct Node {
    int data;
    struct Node* next;
};

// Function to insert node in a linked list
struct Node* create(struct Node* head, int x)
{
    struct Node *temp, *ptr = head;
    temp = new Node();
    temp->data = x;
    temp->next = NULL;
    if (head == NULL)
        head = temp;
    else {
        while (ptr->next != NULL) {
            ptr = ptr->next;
        }
        ptr->next = temp;
    }
    return head;
}

// Function to remove nth node from last
Node* removeNthFromEnd(Node* head, int B)
{
        Node *start = new Node();
        start -> next = head;
        Node* fastPtr = start;
        Node* slowPtr = start;
        // Traverse the LinkedList B times
        for(int i = 0; i < B; i++){
          fastPtr = fastPtr->next;
        }
       //Increase the slow pointer
        while(fastPtr->next != NULL)
        {
            fastPtr = fastPtr->next;
            slowPtr = slowPtr->next;
        }
        //Deletion step
        slowPtr->next = slowPtr->next->next;
       //Return head
        return start->next;
}

// This function prints contents of linked
// list starting from the given node
void display(struct Node* head)
{
    struct Node* temp = head;
    while (temp != NULL) {
        cout << temp->data << " ";
        temp = temp->next;
    }
    cout << endl;
}

// Driver code
int main()
{
    struct Node* head = NULL;
    head = create(head, 1);
    head = create(head, 2);
    head = create(head, 3);
    head = create(head, 4);
    head = create(head, 5);

    int n = 2;

    cout << "Linked list before modification: \n";
    display(head);

    head = removeNthFromEnd(head, 2);
    cout << "Linked list after modification: \n";
    display(head);
    return 0;
}

// This code is contributed by Aditya Kumar (adityakumar129)

C

// C program to delete nth node from last
#include <stdio.h>
#include <stdlib.h>

// Structure of node
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// Function to insert node in a linked list
Node* create(Node* head, int x)
{
    Node* ptr = head;
    Node* temp = (Node*)malloc(sizeof(Node));
    temp->data = x;
    temp->next = NULL;
    if (head == NULL)
        head = temp;
    else {
        while (ptr->next != NULL)
            ptr = ptr->next;
        ptr->next = temp;
    }
    return head;
}

// Function to remove nth node from last
Node* removeNthFromEnd(Node* head, int B)
{
    Node* start = (Node*)malloc(sizeof(Node));
    start->next = head;
    Node* fastPtr = start;
    Node* slowPtr = start;
    // Traverse the LinkedList B times
    for (int i = 0; i < B; i++)
        fastPtr = fastPtr->next;
    // Increase the slow pointer
    while (fastPtr->next != NULL) {
        fastPtr = fastPtr->next;
        slowPtr = slowPtr->next;
    }
    // Deletion step
    slowPtr->next = slowPtr->next->next;
    // Return head
    return start->next;
}

// This function prints contents of linked
// list starting from the given node
void display(struct Node* head)
{
    struct Node* temp = head;
    while (temp != NULL) {
        printf("%d  ", temp->data);
        temp = temp->next;
    }
    printf("\n");
}

// Driver code
int main()
{
    struct Node* head = NULL;
    head = create(head, 1);
    head = create(head, 2);
    head = create(head, 3);
    head = create(head, 4);
    head = create(head, 5);
    int n = 2;
    printf("Linked list before modification: \n");
    display(head);
    head = removeNthFromEnd(head, 2);
    printf("Linked list after modification: \n");
    display(head);
    return 0;
}

// This code is contributed by Aditya Kumar (adityakumar129)

Java

// Java program to delete nth node from last
import java.io.*;

class GFG {

    // Structure of node
    class Node {
        int data;
        Node next;
    }

    // Function to insert node in a linked list
    public Node create(Node head, int x)
    {
        Node temp = new Node();
        Node ptr = head;
        temp.data = x;
        temp.next = null;
        if (head == null) {
            head = temp;
        }
        else {
            while (ptr.next != null) {
                ptr = ptr.next;
            }
            ptr.next = temp;
        }
        return head;
    }

    // Function to remove nth node from last
    public Node removeNthFromEnd(Node head, int B)
    {
        Node start = new Node();
        start.next = head;
        Node fastPtr = start;
        Node slowPtr = start;
        // Traverse the LinkedList B times
        for (int i = 0; i < B; i++) {
            fastPtr = fastPtr.next;
        }
        // Increase the slow pointer
        while (fastPtr.next != null) {
            fastPtr = fastPtr.next;
            slowPtr = slowPtr.next;
        }
        // Deletion step
        slowPtr.next = slowPtr.next.next;
        // Return head
        return start.next;
    }

    // This function prints contents of linked list starting
    // from the given node
    public void display(Node head)
    {
        Node temp = head;
        while (temp != null) {
            System.out.print(temp.data + " ");
            temp = temp.next;
        }
        System.out.println();
    }

    public static void main(String[] args)
    {
        GFG l = new GFG();

        Node head = null;

        head = l.create(head, 1);
        head = l.create(head, 2);
        head = l.create(head, 3);
        head = l.create(head, 4);
        head = l.create(head, 5);

        System.out.println(
            "Linked List before modification: ");
        l.display(head);

        head = l.removeNthFromEnd(head, 2);

        System.out.println(
            "Linked List after modification: ");
        l.display(head);
    }
}

// This code is contributed by lokesh (lokeshmvs21).

Python3

# THIS CODE IS CONTRIBUTED BY KIRTI AGARWAL(KIRTIAGARWAL23121999)
# Python program to delete nth node from last
# structure of node
class Node:
    def __init__(self, key):
        self.data = key
        self.next = None


# function to insert node in a linked list
def create(head, x):
    temp = Node(x)
    ptr = head
    if(head is None):
        head = temp
    else:
        while(ptr.next is not None):
            ptr = ptr.next
        ptr.next = temp

    return head


# function to remove nth node from last
def removeNthFromEnd(head, B):
    start = Node(-1)
    start.next = head
    fastPtr = start
    slowPtr = start
    # traverse the linkedlist B times
    for i in range(B):
        fastPtr = fastPtr.next
    # increase the slow pointer
    while(fastPtr.next is not None):
        fastPtr = fastPtr.next
        slowPtr = slowPtr.next

    # deletion step
    slowPtr.next = slowPtr.next.next
    # return head
    return start.next


# this function prints contents of linked
# list starting from the given node
def display(head):
    temp = head
    while(temp is not None):
        print(temp.data, end=" ")
        temp = temp.next


# driver code to test above function
head = None
head = create(head, 1)
head = create(head, 2)
head = create(head, 3)
head = create(head, 4)
head = create(head, 5)

n = 2

print("Linked list before modification: ")
display(head)

head = removeNthFromEnd(head, 2)
print("\nLinked list after modification: ")
display(head)

C#

// C# program to delete nth node from last
using System;
public class GFG{

  // Structure of node
  class Node {
    public int data;
    public Node next;
  }

  // Function to insert node in a linked list
  Node create(Node head, int x)
  {
    Node temp = new Node();
    Node ptr = head;
    temp.data = x;
    temp.next = null;
    if (head == null) {
      head = temp;
    }
    else {
      while (ptr.next != null) {
        ptr = ptr.next;
      }
      ptr.next = temp;
    }
    return head;
  }

  // Function to remove nth node from last
  Node removeNthFromEnd(Node head, int B)
  {
    Node start = new Node();
    start.next = head;
    Node fastPtr = start;
    Node slowPtr = start;

    // Traverse the LinkedList B times
    for (int i = 0; i < B; i++) {
      fastPtr = fastPtr.next;
    }

    // Increase the slow pointer
    while (fastPtr.next != null) {
      fastPtr = fastPtr.next;
      slowPtr = slowPtr.next;
    }

    // Deletion step
    slowPtr.next = slowPtr.next.next;

    // Return head
    return start.next;
  }

  // This function prints contents of linked list starting
  // from the given node
  void display(Node head)
  {
    Node temp = head;
    while (temp != null) {
      Console.Write(temp.data + " ");
      temp = temp.next;
    }
    Console.WriteLine();
  }

  static public void Main (){

    // Code
    GFG l = new GFG();

    Node head = null;

    head = l.create(head, 1);
    head = l.create(head, 2);
    head = l.create(head, 3);
    head = l.create(head, 4);
    head = l.create(head, 5);

    Console.WriteLine(
      "Linked List before modification: ");
    l.display(head);

    head = l.removeNthFromEnd(head, 2);

    Console.WriteLine(
      "Linked List after modification: ");
    l.display(head);
  }
}

// This code is contributed by lokesh (lokeshmvs21).

Javascript

// JS program to delete nth node from last

// Structure of node
class Node {

    constructor() {
        this.data;
        this.next;
    }
}

// Function to insert node in a linked list
function create(head, x) {
    let temp = new Node();
    let ptr = head;
    temp.data = x;
    temp.next = null;
    if (head == null) {
        head = temp;
    } else {
        while (ptr.next != null) {
            ptr = ptr.next;
        }
        ptr.next = temp;
    }
    return head;
}

// Function to remove nth node from last
function removeNthFromEnd(head, B) {
    let start = new Node();
    start.next = head;
    let fastPtr = start;
    let slowPtr = start;

    // Traverse the LinkedList B times
    for (let i = 0; i < B; i++) {
        fastPtr = fastPtr.next;
    }

    // Increase the slow pointer
    while (fastPtr.next != null) {
        fastPtr = fastPtr.next;
        slowPtr = slowPtr.next;
    }

    // Deletion step
    slowPtr.next = slowPtr.next.next;

    // Return head
    return start.next;
}

// This function prints contents of linked list starting
// from the given node
function display(head) {
    let temp = head;
    while (temp != null) {
        process.stdout.write(temp.data + " ");
        temp = temp.next;
    }
    process.stdout.write("\n");
}

let head = null;

head = create(head, 1);
head = create(head, 2);
head = create(head, 3);
head = create(head, 4);
head = create(head, 5);

console.log("Linked List before modification: ");
display(head);

head = removeNthFromEnd(head, 2);

console.log("Linked List after modification: ");
display(head);

// This code is contributed by phasing17

Output

Linked list before modification: 
1 2 3 4 5 
Linked list after modification: 
1 2 3 5 

Time complexity: O(N) where N is no of nodes in linked list

Space complexity: O(1) because using constant variables