Insert a node after the n-th node from the end
Insert a node x after the nth node from the end in the given singly linked list. It is guaranteed that the list contains the nth node from the end. Also 1 <= n.
Examples:
Input : list: 1->3->4->5
n = 4, x = 2
Output : 1->2->3->4->5
4th node from the end is 1 and
insertion has been done after this node.
Input : list: 10->8->3->12->5->18
n = 2, x = 11
Output : 10->8->3->12->5->11->18
Method 1 (Using length of the list):
Find the length of the linked list, i.e, the number of nodes in the list. Let it be len. Now traverse the list from the 1st node upto the (len-n+1)th node from the beginning and insert the new node after this node. This method requires two traversals of the list.
C++
// C++ implementation to insert a node after // the n-th node from the end #include <bits/stdc++.h> using namespace std; // structure of a node struct Node { int data; Node* next; }; // function to get a new node Node* getNode(int data) { // allocate memory for the node Node* newNode = (Node*)malloc(sizeof(Node)); // put in the data newNode->data = data; newNode->next = NULL; return newNode; } // function to insert a node after the // nth node from the end void insertAfterNthNode(Node* head, int n, int x) { // if list is empty if (head == NULL) return; // get a new node for the value 'x' Node* newNode = getNode(x); Node* ptr = head; int len = 0, i; // find length of the list, i.e, the // number of nodes in the list while (ptr != NULL) { len++; ptr = ptr->next; } // traverse up to the nth node from the end ptr = head; for (i = 1; i <= (len - n); i++) ptr = ptr->next; // insert the 'newNode' by making the // necessary adjustment in the links newNode->next = ptr->next; ptr->next = newNode; } // function to print the list void printList(Node* head) { while (head != NULL) { cout << head->data << " "; head = head->next; } } // Driver program to test above int main() { // Creating list 1->3->4->5 Node* head = getNode(1); head->next = getNode(3); head->next->next = getNode(4); head->next->next->next = getNode(5); int n = 4, x = 2; cout << "Original Linked List: "; printList(head); insertAfterNthNode(head, n, x); cout << "\nLinked List After Insertion: "; printList(head); return 0; } |
chevron_right
filter_none
Java
// Java implementation to insert a node after // the n-th node from the end class GfG { // structure of a node static class Node { int data; Node next; } // function to get a new node static Node getNode(int data) { // allocate memory for the node Node newNode = new Node(); // put in the data newNode.data = data; newNode.next = null; return newNode; } // function to insert a node after the // nth node from the end static void insertAfterNthNode(Node head, int n, int x) { // if list is empty if (head == null) return; // get a new node for the value 'x' Node newNode = getNode(x); Node ptr = head; int len = 0, i; // find length of the list, i.e, the // number of nodes in the list while (ptr != null) { len++; ptr = ptr.next; } // traverse up to the nth node from the end ptr = head; for (i = 1; i <= (len - n); i++) ptr = ptr.next; // insert the 'newNode' by making the // necessary adjustment in the links newNode.next = ptr.next; ptr.next = newNode; } // function to print the list static void printList(Node head) { while (head != null) { System.out.print(head.data + " "); head = head.next; } } // Driver code public static void main(String[] args) { // Creating list 1->3->4->5 Node head = getNode(1); head.next = getNode(3); head.next.next = getNode(4); head.next.next.next = getNode(5); int n = 4, x = 2; System.out.print("Original Linked List: "); printList(head); insertAfterNthNode(head, n, x); System.out.println(); System.out.print("Linked List After Insertion: "); printList(head); } } // This code is contributed by prerna saini |
chevron_right
filter_none
C#
// C# implementation to insert a node after // the n-th node from the end using System; class GfG { // structure of a node public class Node { public int data; public Node next; } // function to get a new node static Node getNode(int data) { // allocate memory for the node Node newNode = new Node(); // put in the data newNode.data = data; newNode.next = null; return newNode; } // function to insert a node after the // nth node from the end static void insertAfterNthNode(Node head, int n, int x) { // if list is empty if (head == null) return; // get a new node for the value 'x' Node newNode = getNode(x); Node ptr = head; int len = 0, i; // find length of the list, i.e, the // number of nodes in the list while (ptr != null) { len++; ptr = ptr.next; } // traverse up to the nth node from the end ptr = head; for (i = 1; i <= (len - n); i++) ptr = ptr.next; // insert the 'newNode' by making the // necessary adjustment in the links newNode.next = ptr.next; ptr.next = newNode; } // function to print the list static void printList(Node head) { while (head != null) { Console.Write(head.data + " "); head = head.next; } } // Driver code public static void Main(String[] args) { // Creating list 1->3->4->5 Node head = getNode(1); head.next = getNode(3); head.next.next = getNode(4); head.next.next.next = getNode(5); int n = 4, x = 2; Console.Write("Original Linked List: "); printList(head); insertAfterNthNode(head, n, x); Console.WriteLine(); Console.Write("Linked List After Insertion: "); printList(head); } } // This code has been contributed by 29AjayKumar |
chevron_right
filter_none
Output:
Original Linked List: 1 3 4 5 Linked List After Insertion: 1 2 3 4 5
Time Complexity: O(n), where n is the number of nodes in the list.
Method 2 (Single traversal):
This method uses two pointers, one is slow_ptr and the other is fast_ptr. First move the fast_ptr up to the nth node from the beginning. Make the slow_ptr point to the 1st node of the list. Now, simultaneously move both the pointers until fast_ptr points to the last node. At this point the slow_ptr will be pointing to the nth node from the end. Insert the new node after this node. This method requires single traversal of the list.
C++
// C++ implementation to insert a node after the // nth node from the end #include <bits/stdc++.h> using namespace std; // structure of a node struct Node { int data; Node* next; }; // function to get a new node Node* getNode(int data) { // allocate memory for the node Node* newNode = (Node*)malloc(sizeof(Node)); // put in the data newNode->data = data; newNode->next = NULL; return newNode; } // function to insert a node after the // nth node from the end void insertAfterNthNode(Node* head, int n, int x) { // if list is empty if (head == NULL) return; // get a new node for the value 'x' Node* newNode = getNode(x); // Initializing the slow and fast pointers Node* slow_ptr = head; Node* fast_ptr = head; // move 'fast_ptr' to point to the nth node // from the beginning for (int i = 1; i <= n - 1; i++) fast_ptr = fast_ptr->next; // iterate until 'fast_ptr' points to the // last node while (fast_ptr->next != NULL) { // move both the pointers to the // respective next nodes slow_ptr = slow_ptr->next; fast_ptr = fast_ptr->next; } // insert the 'newNode' by making the // necessary adjustment in the links newNode->next = slow_ptr->next; slow_ptr->next = newNode; } // function to print the list void printList(Node* head) { while (head != NULL) { cout << head->data << " "; head = head->next; } } // Driver program to test above int main() { // Creating list 1->3->4->5 Node* head = getNode(1); head->next = getNode(3); head->next->next = getNode(4); head->next->next->next = getNode(5); int n = 4, x = 2; cout << "Original Linked List: "; printList(head); insertAfterNthNode(head, n, x); cout << "\nLinked List After Insertion: "; printList(head); return 0; } |
chevron_right
filter_none
Java
// Java implementation to // insert a node after the // nth node from the end class GfG { // structure of a node static class Node { int data; Node next; } // function to get a new node static Node getNode(int data) { // allocate memory for the node Node newNode = new Node(); // put in the data newNode.data = data; newNode.next = null; return newNode; } // function to insert a node after // the nth node from the end static void insertAfterNthNode(Node head, int n, int x) { // if list is empty if (head == null) return; // get a new node for the value 'x' Node newNode = getNode(x); // Initializing the slow // and fast pointers Node slow_ptr = head; Node fast_ptr = head; // move 'fast_ptr' to point to the // nth node from the beginning for (int i = 1; i <= n - 1; i++) fast_ptr = fast_ptr.next; // iterate until 'fast_ptr' points // to the last node while (fast_ptr.next != null) { // move both the pointers to the // respective next nodes slow_ptr = slow_ptr.next; fast_ptr = fast_ptr.next; } // insert the 'newNode' by making the // necessary adjustment in the links newNode.next = slow_ptr.next; slow_ptr.next = newNode; } // function to print the list static void printList(Node head) { while (head != null) { System.out.print(head.data + " "); head = head.next; } } // Driver code public static void main(String[] args) { // Creating list 1->3->4->5 Node head = getNode(1); head.next = getNode(3); head.next.next = getNode(4); head.next.next.next = getNode(5); int n = 4, x = 2; System.out.println("Original Linked List: "); printList(head); insertAfterNthNode(head, n, x); System.out.println(); System.out.println("Linked List After Insertion: "); printList(head); } } // This code is contributed by // Prerna Saini. |
chevron_right
filter_none
C#
// C# implementation to // insert a node after the // nth node from the end using System; class GfG { // structure of a node public class Node { public int data; public Node next; } // function to get a new node static Node getNode(int data) { // allocate memory for the node Node newNode = new Node(); // put in the data newNode.data = data; newNode.next = null; return newNode; } // function to insert a node after // the nth node from the end static void insertAfterNthNode(Node head, int n, int x) { // if list is empty if (head == null) return; // get a new node for the value 'x' Node newNode = getNode(x); // Initializing the slow // and fast pointers Node slow_ptr = head; Node fast_ptr = head; // move 'fast_ptr' to point to the // nth node from the beginning for (int i = 1; i <= n - 1; i++) fast_ptr = fast_ptr.next; // iterate until 'fast_ptr' points // to the last node while (fast_ptr.next != null) { // move both the pointers to the // respective next nodes slow_ptr = slow_ptr.next; fast_ptr = fast_ptr.next; } // insert the 'newNode' by making the // necessary adjustment in the links newNode.next = slow_ptr.next; slow_ptr.next = newNode; } // function to print the list static void printList(Node head) { while (head != null) { Console.Write(head.data + " "); head = head.next; } } // Driver code public static void Main() { // Creating list 1->3->4->5 Node head = getNode(1); head.next = getNode(3); head.next.next = getNode(4); head.next.next.next = getNode(5); int n = 4, x = 2; Console.WriteLine("Original Linked List: "); printList(head); insertAfterNthNode(head, n, x); Console.WriteLine(); Console.WriteLine("Linked List After Insertion: "); printList(head); } } /* This code contributed by PrinciRaj1992 */ |
chevron_right
filter_none
Output:
Original Linked List: 1 3 4 5 Linked List After Insertion: 1 2 3 4 5
Time Complexity: O(n), where n is the number of nodes in the list.
This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
Recommended Posts:
- Program for n'th node from the end of a Linked List
- Write a function to get Nth node in a Linked List
- Given only a pointer/reference to a node to be deleted in a singly linked list, how do you delete it?
- Given only a pointer to a node to be deleted in a singly linked list, how do you delete it?
- Given a linked list which is sorted, how will you insert in sorted way
- Delete a node in a Doubly Linked List
- Sorted insert for circular linked list
- Delete a given node in Linked List under given constraints
- Swap Kth node from beginning with Kth node from end in a Linked List
- Point to next higher value node in a linked list with an arbitrary pointer
- Select a Random Node from a Singly Linked List
- Point arbit pointer to greatest value right side node in a linked list
- Linked List | Set 2 (Inserting a node)
- Linked List | Set 3 (Deleting a node)
- Delete a Linked List node at a given position
