Delete Nth node from the end of the given linked list
Last Updated :
03 Mar, 2025
Given a linked list and an integer N, the task is to delete the Nth node from the end of the given linked list.
Examples:
Input: 2 -> 3 -> 1 -> 7 -> NULL, N = 1
Output: 2 3 1
Explanation: The created linked list is: 2 3 1 7
The linked list after deletion is: 2 3 1
Input: 1 -> 2 -> 3 -> 4 -> NULL, N = 4
Output: 2 3 4
Explanation: The created linked list is: 1 2 3 4
The linked list after deletion is: 2 3 4
Input: 5 -> 3 -> 8 -> 6 -> NULL, N = 2
Output: 5 3 6
Explanation: The created linked list is: 5 3 8 6
The linked list after deletion is: 5 3 6
Approach - Using Length of List - O(n) time and O(1) space
The idea is to first determine the length of the linked list (k) by traversing it once. Once the length is known, the node to be removed is the (k - n + 1)th node from the beginning. We then traverse the list again to reach the node just before the one to be deleted and adjust its next pointer to skip the target node, effectively removing it from the list. If the node to be removed is the head (i.e., k - n == 0), we simply return the second node as the new head.
C++
// C++ code for the deleting a node from end
// in two traversal
#include <bits/stdc++.h>
using namespace std;
class Node {
public:
int data;
Node* next;
Node(int x) {
this->data = x;
this->next = NULL;
}
};
Node* deleteNthNodeFromEnd(Node* head, int n) {
int k = 0;
Node* curr = head;
// Find length of list
while (curr != nullptr) {
curr = curr->next;
k++;
}
// if head is the nth node from end
if (k-n == 0) return head->next;
// Reach the node just before
// the target node.
curr = head;
for (int i=1; i<k-n; i++) {
curr = curr->next;
}
// Skip the target node
curr->next = curr->next->next;
return head;
}
int main() {
Node* head = new Node(1);
head->next = new Node(2);
head->next->next = new Node(3);
head->next->next->next = new Node(4);
head->next->next->next->next = new Node(5);
head = deleteNthNodeFromEnd(head, 4);
Node* curr = head;
while (curr) {
cout << curr->data << " ";
curr = curr->next;
}
cout << endl;
return 0;
}
// Java code for the deleting a node from end
// in two traversal
class Node {
int data;
Node next;
Node(int x) {
this.data = x;
this.next = null;
}
}
class GfG {
static Node deleteNthNodeFromEnd(Node head, int n) {
int k = 0;
Node curr = head;
// Find length of list
while (curr != null) {
curr = curr.next;
k++;
}
// if head is the nth node from end
if (k - n == 0) return head.next;
// Reach the node just before
// the target node.
curr = head;
for (int i = 1; i < k - n; i++) {
curr = curr.next;
}
// Skip the target node
curr.next = curr.next.next;
return head;
}
public static void main(String[] args) {
Node head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);
head = deleteNthNodeFromEnd(head, 4);
Node curr = head;
while (curr != null) {
System.out.print(curr.data + " ");
curr = curr.next;
}
System.out.println();
}
}
# Python code for the deleting a node from end
# in two traversal
class Node:
def __init__(self, x):
self.data = x
self.next = None
def deleteNthNodeFromEnd(head, n):
k = 0
curr = head
# Find length of list
while curr:
curr = curr.next
k += 1
# if head is the nth node from end
if k - n == 0:
return head.next
# Reach the node just before
# the target node.
curr = head
for _ in range(1, k - n):
curr = curr.next
# Skip the target node
curr.next = curr.next.next
return head
if __name__ == "__main__":
head = Node(1)
head.next = Node(2)
head.next.next = Node(3)
head.next.next.next = Node(4)
head.next.next.next.next = Node(5)
head = deleteNthNodeFromEnd(head, 4)
curr = head
while curr:
print(curr.data, end=" ")
curr = curr.next
print()
// C# code for the deleting a node from end
// in two traversal
using System;
class Node {
public int data;
public Node next;
public Node(int x) {
this.data = x;
this.next = null;
}
}
class GfG {
static Node deleteNthNodeFromEnd(Node head, int n) {
int k = 0;
Node curr = head;
// Find length of list
while (curr != null) {
curr = curr.next;
k++;
}
// if head is the nth node from end
if (k - n == 0) return head.next;
// Reach the node just before
// the target node.
curr = head;
for (int i = 1; i < k - n; i++) {
curr = curr.next;
}
// Skip the target node
curr.next = curr.next.next;
return head;
}
static void Main(string[] args) {
Node head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);
head = deleteNthNodeFromEnd(head, 4);
Node curr = head;
while (curr != null) {
Console.Write(curr.data + " ");
curr = curr.next;
}
Console.WriteLine();
}
}
// JavaScript code for the deleting a node from end
// in two traversal
class Node {
constructor(x) {
this.data = x;
this.next = null;
}
}
function deleteNthNodeFromEnd(head, n) {
let k = 0;
let curr = head;
// Find length of list
while (curr) {
curr = curr.next;
k++;
}
// if head is the nth node from end
if (k - n === 0) return head.next;
// Reach the node just before
// the target node.
curr = head;
for (let i = 1; i < k - n; i++) {
curr = curr.next;
}
// Skip the target node
curr.next = curr.next.next;
return head;
}
let head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);
head = deleteNthNodeFromEnd(head, 4);
let curr = head;
while (curr) {
process.stdout.write(curr.data + " ");
curr = curr.next;
}
console.log();
Approach - Using Fast and Slow Pointers - O(n) time and O(1) space
The idea is to use two pointers, fast and slow, to traverse the linked list. The fast pointer is moved n steps ahead first, and then both pointers are moved together until fast reaches the end. At this point, slow will be just before the node to be deleted, allowing us to remove the nth node from the end efficiently in a single pass.
C++
// C++ code for the deleting a node from end
// in two traversal
#include <bits/stdc++.h>
using namespace std;
class Node {
public:
int data;
Node* next;
Node(int x) {
this->data = x;
this->next = NULL;
}
};
Node* deleteNthNodeFromEnd(Node* head, int n) {
Node* fast = head;
Node* slow = head;
// Move the fast pointer n nodes
for (int i = 0; i < n; i++)
fast = fast->next;
// If fast becomes NULL, then head
// is the nth node from end.
if (fast == nullptr)
return head->next;
// Move both pointers until fast reaches the end
while (fast->next != nullptr) {
fast = fast->next;
slow = slow->next;
}
// Remove the nth node from the end
slow->next = slow->next->next;
return head;
}
int main() {
Node* head = new Node(1);
head->next = new Node(2);
head->next->next = new Node(3);
head->next->next->next = new Node(4);
head->next->next->next->next = new Node(5);
head = deleteNthNodeFromEnd(head, 4);
Node* curr = head;
while (curr) {
cout << curr->data << " ";
curr = curr->next;
}
cout << endl;
return 0;
}
// Java code for the deleting a node from end
// in two traversal
import java.util.ArrayList;
class Node {
int data;
Node next;
Node(int x) {
this.data = x;
this.next = null;
}
}
class GfG {
static Node deleteNthNodeFromEnd(Node head, int n) {
Node fast = head;
Node slow = head;
// Move the fast pointer n nodes
for (int i = 0; i < n; i++)
fast = fast.next;
// If fast becomes NULL, then head
// is the nth node from end.
if (fast == null)
return head.next;
// Move both pointers until fast reaches the end
while (fast.next != null) {
fast = fast.next;
slow = slow.next;
}
// Remove the nth node from the end
slow.next = slow.next.next;
return head;
}
public static void main(String[] args) {
Node head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);
head = deleteNthNodeFromEnd(head, 4);
Node curr = head;
while (curr != null) {
System.out.print(curr.data + " ");
curr = curr.next;
}
System.out.println();
}
}
# Python code for the deleting a node from end
# in two traversal
class Node:
def __init__(self, x):
self.data = x
self.next = None
def deleteNthNodeFromEnd(head, n):
fast = head
slow = head
# Move the fast pointer n nodes
for _ in range(n):
fast = fast.next
# If fast becomes None, then head
# is the nth node from end.
if fast is None:
return head.next
# Move both pointers until fast reaches the end
while fast.next is not None:
fast = fast.next
slow = slow.next
# Remove the nth node from the end
slow.next = slow.next.next
return head
if __name__ == "__main__":
head = Node(1)
head.next = Node(2)
head.next.next = Node(3)
head.next.next.next = Node(4)
head.next.next.next.next = Node(5)
head = deleteNthNodeFromEnd(head, 4)
curr = head
while curr:
print(curr.data, end=" ")
curr = curr.next
print()
// C# code for the deleting a node from end
// in two traversal
using System;
using System.Collections.Generic;
class Node {
public int data;
public Node next;
public Node(int x) {
this.data = x;
this.next = null;
}
}
class GfG {
static Node deleteNthNodeFromEnd(Node head, int n) {
Node fast = head;
Node slow = head;
// Move the fast pointer n nodes
for (int i = 0; i < n; i++)
fast = fast.next;
// If fast becomes NULL, then head
// is the nth node from end.
if (fast == null)
return head.next;
// Move both pointers until fast reaches the end
while (fast.next != null) {
fast = fast.next;
slow = slow.next;
}
// Remove the nth node from the end
slow.next = slow.next.next;
return head;
}
static void Main() {
Node head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);
head = deleteNthNodeFromEnd(head, 4);
Node curr = head;
while (curr != null) {
Console.Write(curr.data + " ");
curr = curr.next;
}
Console.WriteLine();
}
}
// JavaScript code for the deleting a node from end
// in two traversal
class Node {
constructor(x) {
this.data = x;
this.next = null;
}
}
function deleteNthNodeFromEnd(head, n) {
let fast = head;
let slow = head;
// Move the fast pointer n nodes
for (let i = 0; i < n; i++)
fast = fast.next;
// If fast becomes null, then head
// is the nth node from end.
if (fast === null)
return head.next;
// Move both pointers until fast reaches the end
while (fast.next !== null) {
fast = fast.next;
slow = slow.next;
}
// Remove the nth node from the end
slow.next = slow.next.next;
return head;
}
let head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);
head = deleteNthNodeFromEnd(head, 4);
let curr = head;
while (curr !== null) {
process.stdout.write(curr.data + " ");
curr = curr.next;
}
console.log();
Similar Reads
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 : LinkedList = 1 ->2 ->3 ->4 ->5 , N = 2Output : 1 ->2 ->3 ->5Explanation: Linked list after deleting the 2nd node from last which is 4, is 1 ->2 ->3 ->5 Input : Link
15+ min read
Program for Nth node from the end of a Linked List Given a Linked List of M nodes and a number N, find the value at the Nth node from the end of the Linked List. If there is no Nth node from the end, print -1.Examples:Input: 1 -> 2 -> 3 -> 4, N = 3Output: 2Explanation: Node 2 is the third node from the end of the linked list.Input: 35 ->
14 min read
XOR Linked List - Find Nth Node from the end Given a XOR linked list and an integer N, the task is to print the Nth node from the end of the given XOR linked list. Examples: Input: 4 –> 6 –> 7 –> 3, N = 1 Output: 3 Explanation: 1st node from the end is 3.Input: 5 –> 8 –> 9, N = 4 Output: Wrong Input Explanation: The given Xor Li
15+ min read
Move first element to end of a given Linked List Write a C function that moves first element to end in a given Singly Linked List. For example, if the given Linked List is 1->2->3->4->5, then the function should change the list to 2->3->4->5->1. Algorithm: Traverse the list till last node. Use two pointers: one to store the
13 min read
Delete Kth nodes from the beginning and end of a Linked List Given a singly Linked List and an integer K denoting the position of a Linked List, the task is to delete the Kth node from the beginning and end of the Linked List. Examples: Input: 1 ? 2 ? 3 ? 4 ? 5 ? 6, K = 3Output: 1 ? 2 ? 5 ? 6Explanation: Deleted Nodes : 3, 4 Input: 1 ? 2 ? 3 ? 4 ? 5 ? 6, K =
13 min read
Recursive Approach to find nth node from the end in the linked list Find the nth node from the end in the given linked list using a recursive approach. Examples: Input : list: 4->2->1->5->3 n = 2 Output : 5 Algorithm: findNthFromLast(head, n, count, nth_last) if head == NULL then return findNthFromLast(head->next, n, count, nth_last) count = count + 1
8 min read