Write a function to get Nth node in a Linked List (original) (raw)

Last Updated : 23 Aug, 2024

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
• [Expected Approach-2] Iterative Method - O(n) Time and O(1) Space

**[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

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

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

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

C#

// 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 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mrow><mi>i</mi><mi>n</mi><mi>d</mi><mi>e</mi><mi>x</mi></mrow><mi>i</mi><mi>s</mi></mrow><annotation encoding="application/x-tex">{index} is </annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord"><span class="mord mathnormal">in</span><span class="mord mathnormal">d</span><span class="mord mathnormal">e</span><span class="mord mathnormal">x</span></span><span class="mord mathnormal">i</span><span class="mord mathnormal">s</span></span></span></span>{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)