Cpp14 Program For Printing Nth Node From The End Of A Linked List (Duplicate)
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 list and n = 3, then output is “B”
Method 1 (Use length of linked list)
1) Calculate the length of 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 second pointer used to store the address of the first pointer. If we wish to change the value of a variable by a function, we pass pointer to it. And if we wish to change value of a pointer (i. e., it should start pointing to something else), we pass pointer to a pointer.
Below is the implementation of the above approach:
C++14
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
struct Node* next;
};
void printNthFromLast( struct Node* head, int n)
{
int len = 0, i;
struct Node* temp = head;
while (temp != NULL) {
temp = temp->next;
len++;
}
if (len < n)
return ;
temp = head;
for (i = 1; i < len - n + 1; i++)
temp = temp->next;
cout << temp->data;
return ;
}
void push( struct Node** head_ref, int new_data)
{
struct Node* new_node = new Node();
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
int main()
{
struct Node* head = NULL;
push(&head, 20);
push(&head, 4);
push(&head, 15);
push(&head, 35);
printNthFromLast(head, 4);
return 0;
}
|
Time Complexity: O(n) where n is the length of linked list.
Space Complexity: O(1) because using constant space for pointer manipulation
Method 2 (Use two pointers)
Maintain two pointers – reference pointer and 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:
Below is the implementation of the above approach:
C++14
#include <bits/stdc++.h>
using namespace std;
struct node {
int data;
node* next;
node( int val)
{
data = val;
next = NULL;
}
};
struct llist {
node* head;
llist() { head = NULL; }
void insertAtBegin( int val)
{
node* newNode = new node(val);
newNode->next = head;
head = newNode;
}
void nthFromEnd( int n)
{
node* main_ptr = head;
node* ref_ptr = head;
if (head == NULL) {
cout << "List is empty" << endl;
return ;
}
for ( int i = 1; i < n; i++) {
ref_ptr = ref_ptr->next;
if (ref_ptr == NULL) {
cout << n
<< " is greater than no. of nodes in "
"the list"
<< endl;
return ;
}
}
while (ref_ptr != NULL && ref_ptr->next != NULL) {
ref_ptr = ref_ptr->next;
main_ptr = main_ptr->next;
}
cout << "Node no. " << n
<< " from end is: " << main_ptr->data << endl;
}
void displaylist()
{
node* temp = head;
while (temp != NULL) {
cout << temp->data << "->" ;
temp = temp->next;
}
cout << "NULL" << endl;
}
};
int main()
{
llist ll;
ll.insertAtBegin(20);
ll.insertAtBegin(4);
ll.insertAtBegin(15);
ll.insertAtBegin(35);
ll.displaylist();
ll.nthFromEnd(4);
return 0;
}
|
Output
Node no. 4 from last is 35
Time Complexity: O(n) where n is the length of linked list. Please refer complete article on Program for n’th node from the end of a Linked List for more details!
Auxiliary Space: O(1)
Last Updated :
17 Aug, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...