Open In App

# Python Program For Inserting 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.

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

Output

```Original Linked List:
1 3 4 5
1 2 3 4 5 ```

Time Complexity: O(n), where n is the number of nodes in the list.
Auxiliary space: O(1) because using constant space

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.

## 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)` `    ``print``()``    ` `    ``insertAfterNthNode(head, n, x)` `    ``print``(``"Linked List After Insertion: "``, end ``=` `'')``    ``printList(head)` `# This code is contributed by rutvik_56`

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) because using constant space

Please refer complete article on Insert a node after the n-th node from the end for more details!

### Using two pointers:

Approach:

In this approach, we use two pointers, one that is n steps ahead of the other. Once the first pointer reaches the end of the list, the second pointer will be at the nth node from the end. We can then insert the new node after this node.

The Node class has two instance variables: data and next. data stores the value of the node, and next stores a reference to the next node in the list.

The LinkedList class has one instance variable: head. head stores a reference to the first node in the list.

The LinkedList class defines a method insert_after_nth_from_end that inserts a new node with the value x after the nth node from the end of the list.

The method first iterates through the list to count the number of nodes. If the count is less than n, the method returns without making any changes to the list. Otherwise, it iterates through the list again to find the nth node from the end.

It then creates a new node with the value x, inserts it after the nth node from the end, and updates the references of the surrounding nodes accordingly.

The LinkedList class also defines a method print_list that prints the values of all the nodes in the list, separated by spaces.

In the example code provided, a linked list is created with four nodes: 1 -> 3 -> 4 -> 5. The insert_after_nth_from_end method is then called with arguments 4 and 2, which means a new node with the value 2 should be inserted after the fourth node from the end of the list.

## Python3

 `class` `Node:``    ``def` `__init__(``self``, data``=``None``):``        ``self``.data ``=` `data``        ``self``.``next` `=` `None` `class` `LinkedList:``    ``def` `__init__(``self``):``        ``self``.head ``=` `None``        ` `    ``def` `insert_after_nth_from_end(``self``, n, x):``        ``temp ``=` `self``.head``        ``count ``=` `0``        ` `        ``while` `temp:``            ``temp ``=` `temp.``next``            ``count ``+``=` `1``        ` `        ``if` `count < n:``            ``return``        ` `        ``temp ``=` `self``.head``        ``for` `i ``in` `range``(count``-``n):``            ``temp ``=` `temp.``next``        ` `        ``new_node ``=` `Node(x)``        ``new_node.``next` `=` `temp.``next``        ``temp.``next` `=` `new_node``        ` `    ``def` `print_list(``self``):``        ``temp ``=` `self``.head``        ``while` `temp:``            ``print``(temp.data, end``=``' '``)``            ``temp ``=` `temp.``next``        ``print``()` `llist ``=` `LinkedList()``llist.head ``=` `Node(``1``)``second ``=` `Node(``3``)``third ``=` `Node(``4``)``fourth ``=` `Node(``5``)` `llist.head.``next` `=` `second``second.``next` `=` `third``third.``next` `=` `fourth` `llist.insert_after_nth_from_end(``4``, ``2``)``llist.print_list()`

Output

`1 2 3 4 5 `

Time complexity: O(n)
Auxiliary Space: O(1)