Program for Nth node from the end of a Linked List
Last Updated :
01 Aug, 2024
Improve
Try it on GfG Practice 
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 = 3
Output: 2
Explanation: Node 2 is the third node from the end of the linked list.Input: 35 -> 15 -> 4 -> 20, N = 4
Output: 35
Explanation: Node 35 is the fourth node from the end of the linked list.
Table of Content
[Naive Approach] Finding the length of list – Two Pass – O(M) Time and O(1) Space
The idea is to count the number of nodes in linked list in the first pass, say len. In the second pass, return the (len – n + 1)th nodes from beginning of the Linked List.
// C++ program to find Nth node from end of linked list
#include <bits/stdc++.h>
using namespace std;
// Link list node
struct Node {
int data;
Node* next;
// Constructor to initialize a new node with data
Node(int new_data) {
data = new_data;
next = nullptr;
}
};
// Function to find the Nth node from the last of a linked list
int findNthFromLast(Node* head, int N) {
int len = 0, i;
// Pointer to store the copy of head
Node* temp = head;
// Count the number of nodes in Linked List
while (temp != NULL) {
temp = temp->next;
len++;
}
// Check if value of N is not
// more than length of the linked list
if (len < N)
return -1;
temp = head;
// Get the (len - N + 1)th node from the beginning
for (i = 1; i < len - N + 1; i++)
temp = temp->next;
return temp->data;
}
int main() {
// Create a hard-coded linked list:
// 35 -> 15 -> 4 -> 20
Node* head = new Node(35);
head->next = new Node(15);
head->next->next = new Node(4);
head->next->next->next = new Node(20);
// Function Call to find the 4th node from end
cout << findNthFromLast(head, 4);
return 0;
}
// C program to find Nth node from end of linked list
#include <stdio.h>
// Link list node
struct Node {
int data;
struct Node* next;
};
// Function to find the Nth node from the last of a linked list
int findNthFromLast(struct Node* head, int N) {
int len = 0, i;
// Pointer to store the copy of head
struct Node* temp = head;
// Count the number of nodes in Linked List
while (temp != NULL) {
temp = temp->next;
len++;
}
// Check if value of N is not more than length of the linked list
if (len < N)
return -1;
temp = head;
// Get the (len - N + 1)th node from the beginning
for (i = 1; i < len - N + 1; i++)
temp = temp->next;
return temp->data;
}
// Function to create a new node
struct Node* createNode(int new_data) {
struct Node* new_node =
(struct Node*)malloc(sizeof(struct Node));
new_node->data = new_data;
new_node->next = NULL;
return new_node;
}
int main() {
// Create a hard-coded linked list:
// 35 -> 15 -> 4 -> 20
struct Node* head = createNode(35);
head->next = createNode(15);
head->next->next = createNode(4);
head->next->next->next = createNode(20);
// Function Call to find the 4th node from end
printf("%d\n", findNthFromLast(head, 4));
return 0;
}
// Java program to find Nth node from
// end of linked list
// Link list node
class Node {
int data;
Node next;
// Constructor to initialize a new node with data
Node(int new_data) {
data = new_data;
next = null;
}
}
public class GFG {
// Function to find the Nth node from the last of a linked list
static int findNthFromLast(Node head, int N) {
int len = 0, i;
// Pointer to store the copy of head
Node temp = head;
// Count the number of nodes in Linked List
while (temp != null) {
temp = temp.next;
len++;
}
// Check if value of N is not more than length of the linked list
if (len < N)
return -1;
temp = head;
// Get the (len - N + 1)th node from the beginning
for (i = 1; i < len - N + 1; i++)
temp = temp.next;
return temp.data;
}
public static void main(String[] args) {
// Create a hard-coded linked list:
// 35 -> 15 -> 4 -> 20
Node head = new Node(35);
head.next = new Node(15);
head.next.next = new Node(4);
head.next.next.next = new Node(20);
// Function Call to find the 4th node from end
System.out.println(findNthFromLast(head, 4));
}
}
# Python3 program to find Nth node from end of linked list
# Link list node
class Node:
# Constructor to initialize a new node with data
def __init__(self, new_data):
self.data = new_data
self.next = None
# Function to find the Nth node from the last of a linked list
def findNthFromLast(head, N):
length = 0
temp = head
# Count the number of nodes in Linked List
while temp is not None:
temp = temp.next
length += 1
# Check if value of N is not more than length of the linked list
if length < N:
return -1
temp = head
# Get the (length - N + 1)th node from the beginning
for _ in range(1, length - N + 1):
temp = temp.next
return temp.data
if __name__ == "__main__":
# Create a hard-coded linked list:
# 35 -> 15 -> 4 -> 20
head = Node(35)
head.next = Node(15)
head.next.next = Node(4)
head.next.next.next = Node(20)
# Function Call to find the 4th node from end
print(findNthFromLast(head, 4))
// C# program to find N'th node from end of linked list
using System;
// Link list node
class Node {
public int data;
public Node next;
// Constructor to initialize a new node with data
public Node(int new_data) {
data = new_data;
next = null;
}
}
// Function to find the Nth node from the last of a linked list
class GFG {
static int FindNthFromLast(Node head, int N) {
int len = 0;
Node temp = head;
// Count the number of nodes in Linked List
while (temp != null) {
temp = temp.next;
len++;
}
// Check if value of N is not more than length of the linked list
if (len < N)
return -1;
temp = head;
// Get the (len - N + 1)th node from the beginning
for (int i = 1; i < len - N + 1; i++)
temp = temp.next;
return temp.data;
}
static void Main() {
// Create a hard-coded linked list:
// 35 -> 15 -> 4 -> 20
Node head = new Node(35);
head.next = new Node(15);
head.next.next = new Node(4);
head.next.next.next = new Node(20);
// Function Call to find the 4th node from end
Console.WriteLine(FindNthFromLast(head, 4));
}
}
// Javascript program to find N'th node from end of linked list
// Link list node
class Node {
// Constructor to initialize a new node with data
constructor(new_data) {
this.data = new_data;
this.next = null;
}
}
// Function to find the Nth node from the last of a linked list
function findNthFromLast(head, N) {
let len = 0;
let temp = head;
// Count the number of nodes in Linked List
while (temp !== null) {
temp = temp.next;
len++;
}
// Check if value of N is not more than length of the linked list
if (len < N) {
return -1;
}
temp = head;
// Get the (len - N + 1)th node from the beginning
for (let i = 1; i < len - N + 1; i++) {
temp = temp.next;
}
return temp.data;
}
// Create a hard-coded linked list:
// 35 -> 15 -> 4 -> 20
let head = new Node(35);
head.next = new Node(15);
head.next.next = new Node(4);
head.next.next.next = new Node(20);
// Function Call to find the 4th node from end
console.log(findNthFromLast(head, 4));
Output
35
Time complexity: O(M) where M is the size of the linked list
Auxiliary Space: O(1)
[Expected Approach] Using Two Pointers – One Pass – O(M) Time and O(1) Space
The idea is to maintain two pointers, say main_ptr and ref_ptr point to the head of Linked List and move ref_ptr to the Nth node from the head to ensure that the distance between main_ptr and ref_ptr is (N – 1). Now, move both the pointers simultaneously until ref_ptr reaches the last node. Since the distance between main_ptr and ref_ptr is (N – 1), so when ref_ptr will reach the last node, main_ptr will reach Nth node from the end of Linked List. Return the value of node pointed by main_ptr.
Below image is a dry run of the above approach:
Follow the given steps to solve the problem:
- Maintain two pointers main_ptr and ref_ptr
- Move ref_ptr to the Nth node from the start
- Now move both main_ptr and ref_ptr, until the ref_ptr reaches the last node
- Now return the data of the main_ptr, as it is at the Nth node from the end
// C++ program to find Nth node from end of linked list
#include <bits/stdc++.h>
using namespace std;
// Link list node
struct Node {
int data;
Node* next;
// Constructor to initialize a new node with data
Node(int new_data) {
data = new_data;
next = nullptr;
}
};
// function to find Nth node from the end of linked list
int nthFromEnd(Node *head, int N) {
// create two pointers main_ptr and ref_ptr
// initially pointing to head.
Node* main_ptr = head;
Node* ref_ptr = head;
// move ref_ptr to the n-th node from beginning.
for (int i = 1; i < N; i++) {
ref_ptr = ref_ptr->next;
// If the ref_ptr reaches NULL, then it means
// N > length of linked list
if (ref_ptr == NULL) {
return -1;
}
}
// move ref_ptr and main_ptr by one node until
// ref_ptr reaches last node of the list.
while (ref_ptr->next != NULL) {
ref_ptr = ref_ptr->next;
main_ptr = main_ptr->next;
}
return main_ptr->data;
}
int main() {
// Create a hard-coded linked list:
// 35 -> 15 -> 4 -> 20
Node* head = new Node(35);
head->next = new Node(15);
head->next->next = new Node(4);
head->next->next->next = new Node(20);
// Function Call to find the 4th node from end
cout << nthFromEnd(head, 4);
return 0;
}
// C program to find Nth node from end of linked list
#include <stdio.h>
// Link list node
struct Node {
int data;
struct Node* next;
};
// Function to find the Nth node from the last of a linked
// list
int findNthFromLast(struct Node* head, int N) {
// Create two pointers main_ptr and ref_ptr initially
// pointing to head
struct Node* main_ptr = head;
struct Node* ref_ptr = head;
// Move ref_ptr to the N-th node from the beginning
for (int i = 1; i < N; i++) {
ref_ptr = ref_ptr->next;
// If the ref_ptr reaches NULL, then it means
// N > length of linked list
if (ref_ptr == NULL) {
return -1;
}
}
// Move ref_ptr and main_ptr by one node until ref_ptr
// reaches the last node of the list
while (ref_ptr->next != NULL) {
ref_ptr = ref_ptr->next;
main_ptr = main_ptr->next;
}
return main_ptr->data;
}
// Function to create a new node
struct Node* createNode(int new_data) {
struct Node* new_node
= (struct Node*)malloc(sizeof(struct Node));
new_node->data = new_data;
new_node->next = NULL;
return new_node;
}
int main() {
// Create a hard-coded linked list:
// 35 -> 15 -> 4 -> 20
struct Node* head = createNode(35);
head->next = createNode(15);
head->next->next = createNode(4);
head->next->next->next = createNode(20);
// Function Call to find the 4th node from end
printf("%d\n", findNthFromLast(head, 4));
return 0;
}
// Java program to find Nth node from end of linked list
// Link list node
class Node {
int data;
Node next;
// Constructor to initialize a new node with data
Node(int new_data) {
data = new_data;
next = null;
}
}
public class GFG {
// Function to find Nth node from the end of linked list
static int nthFromEnd(Node head, int N) {
// Create two pointers main_ptr and ref_ptr
// initially pointing to head.
Node main_ptr = head;
Node ref_ptr = head;
// Move ref_ptr to the N-th node from beginning.
for (int i = 1; i < N; i++) {
ref_ptr = ref_ptr.next;
// If the ref_ptr reaches NULL, then it means
// N > length of linked list
if (ref_ptr == null) {
return -1;
}
}
// Move ref_ptr and main_ptr by one node until
// ref_ptr reaches last node of the list.
while (ref_ptr.next != null) {
ref_ptr = ref_ptr.next;
main_ptr = main_ptr.next;
}
return main_ptr.data;
}
public static void main(String[] args) {
// Create a hard-coded linked list:
// 35 -> 15 -> 4 -> 20
Node head = new Node(35);
head.next = new Node(15);
head.next.next = new Node(4);
head.next.next.next = new Node(20);
// Function Call to find the 4th node from end
System.out.println(nthFromEnd(head, 4));
}
}
# Python3 program to find Nth node from end of linked list
# Link list node
class Node:
# Constructor to initialize a new node with data
def __init__(self, new_data):
self.data = new_data
self.next = None
# Function to find Nth node from the end of linked list
def nth_from_end(head, N):
# Create two pointers main_ptr and ref_ptr
# initially pointing to head.
main_ptr = head
ref_ptr = head
# Move ref_ptr to the N-th node from beginning.
for _ in range(1, N):
ref_ptr = ref_ptr.next
# If the ref_ptr reaches None, then it means
# N > length of linked list
if ref_ptr is None:
return -1
# Move ref_ptr and main_ptr by one node until
# ref_ptr reaches last node of the list.
while ref_ptr.next is not None:
ref_ptr = ref_ptr.next
main_ptr = main_ptr.next
return main_ptr.data
if __name__ == "__main__":
# Create a hard-coded linked list:
# 35 -> 15 -> 4 -> 20
head = Node(35)
head.next = Node(15)
head.next.next = Node(4)
head.next.next.next = Node(20)
# Function Call to find the 4th node from end
print(nth_from_end(head, 4))
// C# program to find Nth node from end of linked list
using System;
class GFG {
// Node class for the linked list
class Node {
public int Data;
public Node Next;
// Constructor to initialize a new node with data
public Node(int newData) {
Data = newData;
Next = null;
}
}
// Function to find the Nth node from the end of the
// linked list
static int NthFromEnd(Node head, int N) {
Node mainPtr = head;
Node refPtr = head;
// Move refPtr to the N-th node from the beginning
for (int i = 1; i < N; i++) {
refPtr = refPtr ?.Next;
// If the refPtr reaches null, then N > length
// of linked list
if (refPtr == null) {
return -1;
}
}
// Move refPtr and mainPtr by one node until refPtr
// reaches the last node
while (refPtr?.Next != null) {
refPtr = refPtr.Next;
mainPtr = mainPtr.Next;
}
return mainPtr.Data;
}
static void Main() {
// Create a hard-coded linked list:
// 35 -> 15 -> 4 -> 20
Node head = new Node(35);
head.Next = new Node(15);
head.Next.Next = new Node(4);
head.Next.Next.Next = new Node(20);
// Function call to find the 4th node from the end
Console.WriteLine(NthFromEnd(head, 4));
}
}
// javascript program to find n'th
// node from end of linked list
// Linked List Node
class Node {
// Constructor to initialize a new node with data
constructor(data) {
this.data = data;
this.next = null;
}
}
// Function to find Nth node from the end of linked list
function nthFromEnd(head, N) {
let mainPtr = head;
let refPtr = head;
// Move refPtr to the N-th node from the beginning
for (let i = 1; i < N; i++) {
refPtr = refPtr.next;
if (refPtr === null) {
// If N is greater than the length of the linked list
return -1;
}
}
// Move refPtr and mainPtr by one node until refPtr reaches the last node
while (refPtr.next !== null) {
refPtr = refPtr.next;
mainPtr = mainPtr.next;
}
return mainPtr.data;
}
// Create a hard-coded linked list:
// 35 -> 15 -> 4 -> 20
const head = new Node(35);
head.next = new Node(15);
head.next.next = new Node(4);
head.next.next.next = new Node(20);
// Function call to find the 4th node from end
console.log(nthFromEnd(head, 4));
Output
Node no. 4 from end is: 35
Time Complexity: O(M) where M is the length of the linked list
Auxiliary Space: O(1)
