Java Program For Printing Nth Node From The End Of A Linked List
Last Updated :
02 Aug, 2022
Given a Linked List and a number n, write a function that returns the value at the n’th node from the end of the Linked List.
For example, if the input is below the list and n = 3, then the output is “B”.
Method 1 (Use length of linked list)
1) Calculate the length of the Linked List. Let the length be len.
2) Print the (len – n + 1)th node from the beginning of the Linked List.
Double pointer concept:
First pointer is used to store the address of the variable and the second pointer is used to store the address of the first pointer. If we wish to change the value of a variable by a function, we pass a pointer to it. And if we wish to change the value of a pointer (i. e., it should start pointing to something else), we pass the pointer to a pointer.
Below is the implementation of the above approach:
Java
class LinkedList {
Node head;
class Node {
int data;
Node next;
Node( int d)
{
data = d;
next = null ;
}
}
void printNthFromLast( int n)
{
int len = 0 ;
Node temp = head;
while (temp != null ) {
temp = temp.next;
len++;
}
if (len < n)
return ;
temp = head;
for ( int i = 1 ; i < len - n + 1 ; i++)
temp = temp.next;
System.out.println(temp.data);
}
public void push( int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
public static void main(String[] args)
{
LinkedList llist = new LinkedList();
llist.push( 20 );
llist.push( 4 );
llist.push( 15 );
llist.push( 35 );
llist.printNthFromLast( 4 );
}
}
|
Time complexity: O(n)
Auxiliary Space: O(1) since using constant space
Following is a recursive C code for the same method. Thanks to Anuj Bansal for providing the following code.
Java
static void printNthFromLast(Node head, int n)
{
static int i = 0 ;
if (head == null )
return ;
printNthFromLast(head.next, n);
if (++i == n)
System.out.print(head.data);
}
|
Time Complexity: O(n) where n is the length of linked list.
Auxiliary Space: O(n) for call stack because using recursion.
Method 2 (Use two pointers)
Maintain two pointers – the reference pointer and the main pointer. Initialize both reference and main pointers to head. First, move the reference pointer to n nodes from head. Now move both pointers one by one until the reference pointer reaches the end. Now the main pointer will point to nth node from the end. Return the main pointer.
Below image is a dry run of the above approach:
Java
class LinkedList {
Node head;
class Node {
int data;
Node next;
Node( int d)
{
data = d;
next = null ;
}
}
void printNthFromLast( int n)
{
Node main_ptr = head;
Node ref_ptr = head;
int count = 0 ;
if (head != null ) {
while (count < n) {
if (ref_ptr == null ) {
System.out.println(
n + " is greater than the no "
+ " of nodes in the list" );
return ;
}
ref_ptr = ref_ptr.next;
count++;
}
if (ref_ptr == null ) {
if (head != null )
System.out.println( "Node no. " + n
+ " from last is "
+ head.data);
}
else {
while (ref_ptr != null ) {
main_ptr = main_ptr.next;
ref_ptr = ref_ptr.next;
}
System.out.println( "Node no. " + n
+ " from last is "
+ main_ptr.data);
}
}
}
public void push( int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
public static void main(String[] args)
{
LinkedList llist = new LinkedList();
llist.push( 20 );
llist.push( 4 );
llist.push( 15 );
llist.push( 35 );
llist.printNthFromLast( 4 );
}
}
|
Output
Node no. 4 from last is 35
Time Complexity: O(n) where n is the length of linked list.
Auxiliary Space: O(1) using constant space.
Please refer complete article on Program for n’th node from the end of a Linked List for more details.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...