Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Python Program For Inserting A Node After The N-th Node From The End

  • Last Updated : 18 May, 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. 

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

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("
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.

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


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!