Write a function to get Nth node in a Linked List

Last Updated : 23 Aug, 2024

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++

//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

// 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

# 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

// 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++

// 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

// 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

# 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");
        }
    }
}

JavaScript

// 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)

Program for Nth node from the end of a Linked List

kartik

Improve

Article Tags :

Practice Tags :

Linked List

Write a function to get Nth node in a Linked List

[Naive Approach] Recursive Method - O(n) Time and O(n) Space

[Expected Approach-2] Iterative Method - O(n) Time and O(1) Space

Similar Reads

Types of Linked List

Basic Operations on Linked List

Thank You!

What kind of Experience do you want to share?