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;
} // function 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;
} // function 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();
// 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 = d
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
# function 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;
} // function 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 |
Javascript
<script> // JavaScript implementation to recursively
// find the nth node from the last
// of the linked list
var count = 0,
data = 0;
// a node of a linked list
class Node {
constructor() {
this .data = 0;
this .next = null ;
}
}
// function to get a new node
function getNode(data) {
// allocate space
var newNode = new Node();
// put in data
newNode.data = data;
newNode.next = null ;
return newNode;
}
// function to recursively
// find the nth node from
// the last of the linked list
function findNthFromLast(head, n, 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
function findNthFromLastUtil(head, n) {
// Initialize
var 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 )
document.write( "Nth node from last is: " + data + "<br>" );
else document.write( "Node does not exists <br>" );
}
// Driver Code
// linked list: 4.2.1.5.3
var 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);
var n = 2;
findNthFromLastUtil(head, n);
</script> |
Output:
Nth node from last is: 5
Time Complexity: O(N), as we are using a loop to traverse N times, where N is the number of Nodes in the linked list.
Auxiliary Space: O(N) for call stack since using recursion