Write a GetNth() function that takes a linked list and an integer index and returns the data value stored in the node at that index position.
Example:
Input: 1 -> 10 -> 30 -> 14, index = 2
Output: 30
Explanation: The node at index 2 is 30
Method 1 – Using Loop
Algorithm:
1. Initialize count = 0
2. Loop through the link list
a. If count is equal to the passed index then return current node
b. Increment count
c. change current to point to next of the current.
Implementation:
Javascript
// Javascript program to find nth // node of a linked list class Node { constructor(d) {
this .data = d;
this .next = null ;
}
} // Head of list let head; /* Takes index as argument and return data at index */
function GetNth(index) {
let current = head;
// Index of Node we are currently
// looking at
let count = 0;
while (current != null ) {
if (count == index)
return current.data;
count++;
current = current.next;
}
/* if we get to this line, the caller
was asking for a non-existent element
so we assert fail */
assert( false );
return 0;
} /* Given a reference to the head of a list and an int, inserts a new Node
on the front of the list */
function push(new_data) {
// 1. Create new Node and put data
let new_Node = new Node(new_data);
// 2. Make next of new Node as head
new_Node.next = head;
// 3. Move the head to point to new Node
head = new_Node;
} // Driver code // Start with empty list // Use push() method to construct list // 1 -> 12 -> 1 -> 4 -> 1 push(1); push(4); push(1); push(12); push(1); // Check the count function console.log( "Element at index 3 is " +
GetNth(3));
|
Output
Element at index 3 is 4
Time Complexity: O(n)
Space Complexity: O(1) since using constant space to create nodes and variables.
Method 2 – Using Recursion
Algorithm:
getnth(node,n)
1. Initialize count = 0
2. if count==n
return node->data
3. else
return getnth(node->next, n-1)
Implementation:
Javascript
// JavaScript program to find n'th node // of a linked list using recursion // Linked List node class Node { constructor(val) {
this .data = val;
this .next = null ;
}
} /* Given a reference (pointer to pointer) to the head of a list and an int, push a new node on
the front of the list. */
function push(head, new_data) {
// Allocate node
let new_node = new Node(new_data);
// Put in the data
new_node.data = new_data;
new_node.next = head;
head = new_node;
return head;
} /* Takes head pointer of the linked list and index as arguments and return data at index */
function GetNth(head, n) {
let count = 0;
// Edge case - if head is null
if (head == null )
return -1;
// if count equal too n return node.data
if (count == n)
return head.data;
// Recursively decrease n and increase
// head to next pointer
return GetNth(head.next, n - 1);
} // Driver code // Start with the empty list let head = null ;
// Use push() to construct list // 1 -> 12 -> 1 -> 4 -> 1 head = push(head, 1); head = push(head, 4); head = push(head, 1); head = push(head, 12); head = push(head, 1); // Check the count function console.log( "Element at index 3 is " ,
GetNth(head, 3));
|
Output
Element at index 3 is 4
Time Complexity: O(n)
Space Complexity: O(n) for call stack because using recursion
Please refer complete article on Write a function to get Nth node in a Linked List for more details!