Write a function to get Nth node in a Linked List
Last Updated :
23 Aug, 2024
Improve
Try it on GfG Practice 
Given a LinkedList and an index (1-based). The task is to find the data value stored in the node at that kth position. If no such node exists whose index is k then return -1.
Example:
Input: 1->10->30->14, index = 2
Output: 10
Explanation: The node value at index 2 is 10
Input: 1->32->12->10->30->14->100, index = 8
Output: -1
Explanation: No such node exists at index = 8.
Table of Content
[Naive Approach] Recursive Method – O(n) Time and O(n) Space
The idea is to use the recursive method to find the value of index node (1- based) . Call the function GetNth(head,index) recusively, where head will represent the current head node . Decrement the index value by 1 on every recursion call. When the n reaches 1 ,we will return the data of current node.
Below is the implementation of above approach:
//C++ program to find the data at nth node
//recursively
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
Node* next;
Node(int x) {
data = x;
next = NULL;
}
};
// Takes head pointer of the linked list and index
// as arguments and returns data at index.
int GetNth(Node* head, int index) {
// If the list is empty or index is out of bounds
if (head == NULL)
return -1;
// If index equals 1, return node's data
if (index == 1)
return head->data;
// Recursively move to the next node
return GetNth(head->next, index - 1);
}
int main() {
// Create a hard-coded linked list:
// 1 -> 2 -> 3 -> 4 -> 5
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);
cout << "Element at index 3 is " << GetNth(head, 3) << endl;
return 0;
}
// C program to find the data at nth node
// recursively
#include <stdio.h>
struct Node {
int data;
struct Node *next;
};
// Takes head pointer of the linked list and index
// as arguments and returns data at index.
int GetNth(struct Node *head, int index) {
// If the list is empty or index is out of bounds
if (head == NULL)
return -1;
// If index equals 1, return node's data
if (index == 1)
return head->data;
// Recursively move to the next node
return GetNth(head->next, index - 1);
}
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:
// 1 -> 2 -> 3 -> 4 -> 5
struct Node *head = createNode(1);
head->next = createNode(2);
head->next->next = createNode(3);
head->next->next->next = createNode(4);
head->next->next->next->next = createNode(5);
printf("Element at index 3 is %d\n", GetNth(head, 3));
return 0;
}
// Java program to find n'th node in linked list
// using recursion
import java.io.*;
class Node {
int data;
Node next;
Node(int x){
data = x;
next = null;
}
}
class GfG {
// Takes head pointer of the linked list and index
// as arguments and return data at index*/
static int GetNth(Node head, int index) {
if (head == null)
return -1;
// if index equal to 1 return node.data
if (index == 1)
return head.data;
// recursively decrease n and increase
// head to next pointer
return GetNth(head.next, index - 1);
}
public static void main(String args[]) {
// Create a hard-coded linked list:
// 1 -> 2 -> 3 -> 4 -> 5
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);
System.out.printf("Element at index 3 is %d",
GetNth(head, 3));
}
}
# Python program to find the Nth node in
# linked list using recursion
class Node:
def __init__(self, x):
self.data = x
self.next = None
# Recursive method to find the Nth node
def get_nth_node(head, index):
# Helper function to handle recursion
#and count tracking
if head is None:
print(-1)
if index == 1:
print(head.data)
else:
get_nth_node(head.next, index-1)
if __name__ == "__main__":
# Create a linked list: 1 -> 2 -> 3 -> 4 -> 5
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)
print("Element at index 3 is", end=" ")
get_nth_node(head, 3)
// C# program to find the Nth node in
// linked list using recursion
using System;
class Node {
public int Data;
public Node Next;
public Node(int x) {
Data = x;
Next = null;
}
}
class GfG {
// Takes head pointer of the linked list and index
// as arguments and returns data at index
static int GetNth(Node head, int index) {
// Base Condition
if (head == null)
return -1;
// If n equals 0, return the node's data
if (index == 1)
return head.Data;
// Recursively move to the next node
return GetNth(head.Next, index - 1);
}
public static void Main() {
// Create a hard-coded linked list:
// 1 -> 2 -> 3 -> 4 -> 5
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);
Console.WriteLine("Element at index 3 is {0}", GetNth(head, 3));
}
}
// JavaScript program to find the n'th node in
// a linked list using recursion
class Node {
constructor(new_data) {
this.data = new_data;
this.next = null;
}
}
function GetNth(head, index) {
// Base case: if the list is empty or index is out of
// bounds
if (head === null) {
return -1;
}
// Base case: if count equals n, return node's data
if (index === 1) {
return head.data;
}
// Recursive case: move to the next node and decrease
// index
return GetNth(head.next, index - 1);
}
// Create a hard-coded linked list:
// 1 -> 2 -> 3 -> 4 -> 5
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);
console.log("Element at index 3 is", GetNth(head, 3));
Output
Element at index 3 is 3
Time Complexity : O(n) ,where n is the nth node of linked list.
Auxiliary Space: O(n), for recursive call stack
[Expected Approach-2] Iterative Method – O(n) Time and O(1) Space
The idea is similar to recursive approach to find the value at index node (1- based) .We will use a variable say, count = 1 to track the nodes. Traverse the list until curr != NULL . Increment the count if count is not equal to index node (1- based) , else if count equals to the index node, return data at current node.
Below is the implementation of above approach :
// C++ program to find n'th
// node in linked list (iteratively)
#include <iostream>
using namespace std;
class Node {
public:
int data;
Node *next;
Node(int x) {
data = x;
next = nullptr;
}
};
// Function to find the nth node in the list
int GetNth(Node *head, int index) {
Node *curr = head;
int count = 1;
while (curr != nullptr) {
if (count == index)
return curr->data;
count++;
curr = curr->next;
}
return -1;
}
int main() {
// Create a hard-coded linked list:
// 1 -> 2 -> 3 -> 4 -> 5
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);
cout << "Element at index 3 is " << GetNth(head, 3) << endl;
return 0;
}
// C program to find n'th
// node in linked list (iteratively)
#include <stdio.h>
struct Node {
int data;
struct Node *next;
};
// Function to find the nth node in the list
int GetNth(struct Node *head, int index)
{
struct Node *curr = head;
int count = 1;
while (curr != NULL) {
if (count == index)
return curr->data;
count++;
curr = curr->next;
}
return -1;
}
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:
// 1 -> 2 -> 3 -> 4 -> 5
struct Node *head = createNode(1);
head->next = createNode(2);
head->next->next = createNode(3);
head->next->next->next = createNode(4);
head->next->next->next->next = createNode(5);
printf("Element at index 3 is %d\n", GetNth(head, 3));
}
// Java program to find the Nth node in
// a linked list iteratively
class Node {
int data;
Node next;
Node(int x) {
data = x;
next = null;
}
}
class GfG {
// Function to find the nth node in the list iteratively
static int getNthNodeIterative(Node head, int index) {
Node current = head;
int count = 1;
// Traverse the list until the end or until the nth
// node is reached
while (current != null) {
if (count == index) {
return current.data;
}
count++;
current = current.next;
}
// Return -1 if the index is out of bounds
return -1;
}
public static void main(String[] args) {
// Create a hard-coded linked list:
// 1 -> 2 -> 3 -> 4 -> 5
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);
int index = 3;
int result = getNthNodeIterative(head, index);
if (result != -1) {
System.out.println("Element at index " + index
+ " is " + result);
}
else {
System.out.println("Index " + index
+ " is out of bounds");
}
}
}
# Python program to find the Nth node in
# a linked list iteratively
class Node:
def __init__(self, x):
self.data = x
self.next = None
# Function to find the nth node in the list iteratively
def get_nth_node_iterative(head, n):
current = head
count = 1
# Traverse the list until the end or until the nth node is reached
while current is not None:
if count == n:
return current.data
count += 1
current = current.next
# Return -1 if the index is out of bounds
return -1
if __name__ == "__main__":
# Create a hard-coded linked list:
# 1 -> 2 -> 3 -> 4 -> 5
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)
index = 3
result = get_nth_node_iterative(head, index)
if result != -1:
print(f"Element at index {index} is {result}")
else:
print(f"Index {index} is out of bounds")
// Iterative C# program to find the nth node in
// a linked list
using System;
class Node {
public int Data;
public Node Next;
public Node(int x) {
Data = x;
Next = null;
}
}
class GfG {
// Given the head of a list and index, find the nth node
// and return its data
static int GetNthNode(Node head, int n) {
Node current = head;
int count = 1;
// Traverse the list until the nth node is found or
// end of the list is reached
while (current != null) {
if (count == n) {
return current.Data;
}
count++;
current = current.Next;
}
// Return -1 if the index is out of bounds
return -1;
}
public static void Main() {
// Create a hard-coded linked list:
// 1 -> 2 -> 3 -> 4 -> 5
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);
int index = 3;
int result = GetNthNode(head, index);
if (result != -1) {
Console.WriteLine($"Element at index {index} is {result}");
}
else {
Console.WriteLine($"Index {index} is out of bounds");
}
}
}
// Iterative JavaScript program to find the Nth node in a
// linked list
class Node {
constructor(x) {
this.data = x;
this.next = null;
}
}
// Given the head of a list and an index, return the data at
// the index
function getNth(head, index) {
let current = head;
let count = 1;
// Traverse the linked list
while (current !== null) {
if (count === index) {
// Return data at the current
// node if index matches
return current.data;
}
count++;
current = current.next;
}
// Return -1 if index is out of bounds
return -1;
}
// Create a hard-coded linked list:
// 1 -> 2 -> 3 -> 4 -> 5
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);
let index = 3;
let result = getNth(head, index);
if (result !== -1) {
console.log(`Element at index ${index} is ${result}`);
}
else {
console.log(`Index ${index} is out of bounds`);
}
Output
Element at index 3 is 3
Time Complexity : O(n), where n is the nth node of linked list.
Auxiliary Space: O(1)
