# Insert a node after the n-th node from the end

• Difficulty Level : Easy
• Last Updated : 24 Aug, 2022

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.

Implementation:

## C++

 `// C++ implementation to insert a node after` `// the n-th node from the end` `#include ` `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;` `}`   `// This code is contributed by Sania Kumari Gupta (kriSania804)`

## C

 `// C implementation to insert a node after` `// the n-th node from the end` `#include ` `#include `   `// structure of a node` `typedef` `struct` `Node {` `    ``int` `data;` `    ``struct` `Node* next;` `} Node;`   `// 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) {` `        ``printf``(``"%d "``, 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;`   `    ``printf``(``"Original Linked List: "``);` `    ``printList(head);`   `    ``insertAfterNthNode(head, n, x);`   `    ``printf``(``"\nLinked List After Insertion: "``);` `    ``printList(head);`   `    ``return` `0;` `}`   `// This code is contributed by Sania Kumari Gupta (kriSania804)`

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

## Python3

 `# Python implementation to insert a node after ` `# the n-th node from the end `   `# Linked List node ` `class` `Node: ` `    ``def` `__init__(``self``, data): ` `        ``self``.data ``=` `data ` `        ``self``.``next` `=` `None`   `# function to get a new node ` `def` `getNode(data) :`   `    ``# allocate memory for the node ` `    ``newNode ``=` `Node(``0``) `   `    ``# put in the data ` `    ``newNode.data ``=` `data ` `    ``newNode.``next` `=` `None` `    ``return` `newNode `   `# function to insert a node after the ` `# nth node from the end ` `def` `insertAfterNthNode(head, n, x) :`   `    ``# if list is empty ` `    ``if` `(head ``=``=` `None``) :` `        ``return`   `    ``# get a new node for the value 'x' ` `    ``newNode ``=` `getNode(x) ` `    ``ptr ``=` `head ` `    ``len` `=` `0` `    ``i ``=` `0`   `    ``# find length of the list, i.e, the ` `    ``# number of nodes in the list ` `    ``while` `(ptr !``=` `None``) :` `    `  `        ``len` `=` `len` `+` `1` `        ``ptr ``=` `ptr.``next` `    `  `    ``# traverse up to the nth node from the end ` `    ``ptr ``=` `head ` `    ``i ``=` `1` `    ``while` `( i <``=` `(``len` `-` `n) ) :` `        ``ptr ``=` `ptr.``next` `        ``i ``=` `i ``+` `1`   `    ``# insert the 'newNode' by making the ` `    ``# necessary adjustment in the links ` `    ``newNode.``next` `=` `ptr.``next` `    ``ptr.``next` `=` `newNode `   `# function to print the list ` `def` `printList( head) :`   `    ``while` `(head !``=` `None``):` `    `  `        ``print``(head.data ,end ``=` `" "``) ` `        ``head ``=` `head.``next` `    `  `# Driver code `   `# Creating list 1->3->4->5 ` `head ``=` `getNode(``1``) ` `head.``next` `=` `getNode(``3``) ` `head.``next``.``next` `=` `getNode(``4``) ` `head.``next``.``next``.``next` `=` `getNode(``5``) `   `n ``=` `4` `x ``=` `2`   `print``(``"Original Linked List: "``) ` `printList(head) `   `insertAfterNthNode(head, n, x) ` `print``()` `print``(``"Linked List After Insertion: "``) ` `printList(head) `   `# This code is contributed by Arnab Kundu`

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

## Javascript

 ``

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.
Auxiliary Space: O(1)

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.

Implementation:

## C++

 `// C++ implementation to insert a node after the` `// nth node from the end` `#include `   `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;` `}`

## 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.`

## Python3

 `# Python3 implementation to insert a` `# node after the nth node from the end` ` `  `# Structure of a node` `class` `Node:` `    `  `    ``def` `__init__(``self``, data):` `        `  `        ``self``.data ``=` `data` `        ``self``.``next` `=` `None` `    `  `# Function to get a new node` `def` `getNode(data):` `    `  `    ``# Allocate memory for the node` `    ``newNode ``=` `Node(data)` `    ``return` `newNode`   `# Function to insert a node after the` `# nth node from the end` `def` `insertAfterNthNode(head, n, x):`   `    ``# If list is empty` `    ``if` `(head ``=``=` `None``):` `        ``return` ` `  `    ``# Get a new node for the value 'x'` `    ``newNode ``=` `getNode(x)` ` `  `    ``# Initializing the slow and fast pointers` `    ``slow_ptr ``=` `head` `    ``fast_ptr ``=` `head` ` `  `    ``# Move 'fast_ptr' to point to the nth` `    ``# node from the beginning` `    ``for` `i ``in` `range``(``1``, n):` `        ``fast_ptr ``=` `fast_ptr.``next` ` `  `    ``# Iterate until 'fast_ptr' points to the` `    ``# last node` `    ``while` `(fast_ptr.``next` `!``=` `None``):` ` `  `        ``# 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` `def` `printList(head):`   `    ``while` `(head !``=` `None``):` `        ``print``(head.data, end ``=` `' '``)` `        ``head ``=` `head.``next` `    `  `# Driver code` `if` `__name__``=``=``'__main__'``:` `    `  `    ``# Creating list 1.3.4.5` `    ``head ``=` `getNode(``1``)` `    ``head.``next` `=` `getNode(``3``)` `    ``head.``next``.``next` `=` `getNode(``4``)` `    ``head.``next``.``next``.``next` `=` `getNode(``5``)` ` `  `    ``n ``=` `4` `    ``x ``=` `2` ` `  `    ``print``(``"Original Linked List: "``, end ``=` `'')` `    ``printList(head)` ` `  `    ``insertAfterNthNode(head, n, x)` ` `  `    ``print``(``"\nLinked List After Insertion: "``, end ``=` `'')` `    ``printList(head)` ` `  `# This code is contributed by rutvik_56`

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

## Javascript

 ``

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.
Auxiliary Space: O(1)

Method 3 (Recursive Approach):

• Traverse the list recursively till we reach the last node.
• while back tracking insert the node at desired position.

Implementation:

## C++

 `// C++ implementation to insert a node after the` `// nth node from the end` `#include ` `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 = ``new` `Node();`   `    ``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` `x, ``int``& n)` `{`   `    ``// Base case` `    ``if` `(head == NULL)` `        ``return``;`   `    ``// recursively traverse till the last node` `    ``insertAfterNthNode(head->next, x, n);`   `    ``// condition to insert the node after nth node from end` `    ``if` `(--n == 0) {`   `        ``// create a node with the given value` `        ``Node* temp = getNode(x);`   `        ``// update the next pointer to point next node in the` `        ``// list` `        ``temp->next = head->next;`   `        ``// make sure head points to newly inserted node` `        ``head->next = temp;` `    ``}` `}`   `// function to print the list` `void` `printList(Node* head)` `{` `    ``while` `(head != NULL) {` `        ``cout << head->data << ``" "``;` `        ``head = head->next;` `    ``}` `}`   `// Driver program to test above functions` `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, x, n);`   `    ``cout << ``"\nLinked List After Insertion: "``;` `    ``printList(head);`   `    ``return` `0;` `}` `// This code is contributed by Upendra`

## 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;` `    ``}` `    ``static` `int` `n;` `    ``// function to insert a node after the` `    ``// nth node from the end` `    ``static` `void` `insertAfterNthNode(Node head, ``int` `x)` `    ``{`   `        ``// Base case` `        ``if` `(head == ``null``)` `            ``return``;`   `        ``// recursively traverse till the last node` `        ``insertAfterNthNode(head.next, x);`   `        ``// condition to insert the node after nth node from` `        ``// end` `        ``if` `(--n == ``0``) {`   `            ``// create a node with the given value` `            ``Node temp = getNode(x);`   `            ``// update the next pointer to point next node in` `            ``// the list` `            ``temp.next = head.next;`   `            ``// make sure head points to newly inserted node` `            ``head.next = temp;` `        ``}` `    ``}`   `    ``// 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``);` `        ``n = ``4``;` `        ``int` `x = ``2``;` `        ``System.out.println(``"Original Linked List: "``);` `        ``printList(head);`   `        ``insertAfterNthNode(head, x);` `        ``System.out.println();` `        ``System.out.println(``"Linked List After Insertion: "``);` `        ``printList(head);` `    ``}` `}`   `// This code is contributed by Abhijeet Kumar(abhijeet19403)`

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.

Auxiliary Space: O(n)

Due to recursion call stack.

This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up
Recommended Articles
Page :