Skip to content
Related Articles

Related Articles

Improve Article
Recursive Approach to find nth node from the end in the linked list
  • Difficulty Level : Hard
  • Last Updated : 24 Jan, 2020

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
    if count == n then
        nth_last = head

findNthFromLastUtil(head, n)
    Initialize nth_last = NULL
    Initialize count = 0
    
    findNthFromLast(head, n, &count, &nth_last)
    
    if nth_last != NULL then
        print nth_last->data
    else
        print "Node does not exists"

Note: Parameters count and nth_last will be pointer variables in findNthFromLast().

C++




// C++ implementation to recursively find the nth node from
// the last of the linked list
#include <bits/stdc++.h>
  
using namespace std;
  
// structure of a node of a linked list
struct Node {
    int data;
    Node* next;
};
  
// function to get a new node
Node* getNode(int data)
{
    // allocate space
    Node* newNode = new Node;
  
    // put in data
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}
  
// funnction to recursively find the nth node from
// the last of the linked list
void findNthFromLast(Node* head, int n, int* count,
                     Node** nth_last)
{
    // if list is empty
    if (!head)
        return;
  
    // recursive call
    findNthFromLast(head->next, n, count, nth_last);
  
    // increment count
    *count = *count + 1;
  
    // if true, then head is the nth node from the last
    if (*count == n)
        *nth_last = head;
}
  
// utility function to find the nth node from
// the last of the linked list
void findNthFromLastUtil(Node* head, int n)
{
    // Initialize
    Node* nth_last = NULL;
    int count = 0;
  
    // find nth node from the last
    findNthFromLast(head, n, &count, &nth_last);
  
    // if node exists, then print it
    if (nth_last != NULL)
        cout << "Nth node from last is: "
             << nth_last->data;
    else
        cout << "Node does not exists";
}
  
// Driver program to test above
int main()
{
    // linked list: 4->2->1->5->3
    Node* head = getNode(4);
    head->next = getNode(2);
    head->next->next = getNode(1);
    head->next->next->next = getNode(5);
    head->next->next->next->next = getNode(3);
  
    int n = 2;
  
    findNthFromLastUtil(head, n);
  
    return 0;
}

Java




// Java implementation to recursively 
// find the nth node from the last
// of the linked list 
import java.util.*;
class GFG
{
static int count = 0, data = 0;
  
// a node of a linked list 
static class Node 
    int data; 
    Node next; 
}
  
// function to get a new node 
static Node getNode(int data) 
    // allocate space 
    Node newNode = new Node(); 
  
    // put in data 
    newNode.data = data; 
    newNode.next = null
    return newNode; 
  
// funnction to recursively 
// find the nth node from 
// the last of the linked list 
static void findNthFromLast(Node head, int n, 
                            Node nth_last) 
    // if list is empty 
    if (head == null
        return
  
    // recursive call 
    findNthFromLast(head.next, n, nth_last); 
  
    // increment count 
    count = count + 1
      
    // if true, then head is the
    // nth node from the last 
    if (count == n) 
    {
        data = head.data; 
    }
  
// utility function to find 
// the nth node from the last
// of the linked list 
static void findNthFromLastUtil(Node head, int n) 
    // Initialize 
    Node nth_last = new Node(); 
    count = 0
  
    // find nth node from the last 
    findNthFromLast(head, n, nth_last); 
  
    // if node exists, then print it 
    if (nth_last != null
        System.out.println("Nth node from last is: " +
                                                data); 
    else
        System.out.println("Node does not exists"); 
  
// Driver Code
public static void main(String args[])
    // linked list: 4.2.1.5.3 
    Node head = getNode(4); 
    head.next = getNode(2); 
    head.next.next = getNode(1); 
    head.next.next.next = getNode(5); 
    head.next.next.next.next = getNode(3); 
  
    int n = 2
  
    findNthFromLastUtil(head, n); 
}
  
// This code is contributed 
// by Arnab Kundu

Python




# Python implementation to recursively 
# find the nth node from the last 
# of the linked list 
count = 0
data = 0
  
# a node of a linked list 
class Node(object): 
    def __init__(self, d): 
        self.data =
        self.next = None
  
# function to get a new node 
def getNode(data): 
  
    # allocate space 
    newNode = Node(0
  
    # put in data 
    newNode.data = data 
    newNode.next = None
    return newNode 
  
# funnction to recursively 
# find the nth node from 
# the last of the linked list 
def findNthFromLast(head, n, nth_last) :
  
    global count
    global data
      
    # if list is empty 
    if (head == None): 
        return
  
    # recursive call 
    findNthFromLast(head.next, n, nth_last) 
  
    # increment count 
    count = count + 1
      
    # if true, then head is the 
    # nth node from the last 
    if (count == n) :
      
        data = head.data 
  
# utility function to find 
# the nth node from the last 
# of the linked list 
def findNthFromLastUtil(head, n) :
  
    global count
    global data
      
    # Initialize 
    nth_last = Node(0
    count = 0
  
    # find nth node from the last 
    findNthFromLast(head, n, nth_last) 
  
    # if node exists, then print it 
    if (nth_last != None) :
        print("Nth node from last is: " , data) 
    else:
        print("Node does not exists"
  
# Driver Code 
  
# linked list: 4.2.1.5.3 
head = getNode(4
head.next = getNode(2
head.next.next = getNode(1
head.next.next.next = getNode(5
head.next.next.next.next = getNode(3
  
n = 2
  
findNthFromLastUtil(head, n) 
  
# This code is contributed 
# by Arnab Kundu 

C#




// C# implementation to recursively 
// find the nth node from the last
// of the linked list 
using System;
  
public class GFG
{
    static int count = 0, data = 0;
  
    // a node of a linked list 
    class Node 
    
        public int data; 
        public Node next; 
    }
  
// function to get a new node 
static Node getNode(int data) 
    // allocate space 
    Node newNode = new Node(); 
  
    // put in data 
    newNode.data = data; 
    newNode.next = null
    return newNode; 
  
// funnction to recursively 
// find the nth node from 
// the last of the linked list 
static void findNthFromLast(Node head, int n, 
                            Node nth_last) 
    // if list is empty 
    if (head == null
        return
  
    // recursive call 
    findNthFromLast(head.next, n, nth_last); 
  
    // increment count 
    count = count + 1; 
      
    // if true, then head is the
    // nth node from the last 
    if (count == n) 
    {
        data = head.data; 
    }
  
// utility function to find 
// the nth node from the last
// of the linked list 
static void findNthFromLastUtil(Node head, int n) 
    // Initialize 
    Node nth_last = new Node(); 
    count = 0; 
  
    // find nth node from the last 
    findNthFromLast(head, n, nth_last); 
  
    // if node exists, then print it 
    if (nth_last != null
        Console.WriteLine("Nth node from last is: " +
                                                data); 
    else
        Console.WriteLine("Node does not exists"); 
  
// Driver Code
public static void Main(String []args)
    // linked list: 4.2.1.5.3 
    Node head = getNode(4); 
    head.next = getNode(2); 
    head.next.next = getNode(1); 
    head.next.next.next = getNode(5); 
    head.next.next.next.next = getNode(3); 
  
    int n = 2; 
  
    findNthFromLastUtil(head, n); 
}
  
// This code is contributed by Rajput-Ji


Output:



Nth node from last is: 5

Time Complexity: O(n), where ‘n’ is the number of nodes in the linked list.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live 




My Personal Notes arrow_drop_up
Recommended Articles
Page :