Skip to content
Related Articles

Related Articles

Python Program To Delete Middle Of Linked List

View Discussion
Improve Article
Save Article
Like Article
  • Last Updated : 30 Dec, 2021

Given a singly linked list, delete the middle of the linked list. For example, if the given linked list is 1->2->3->4->5 then the linked list should be modified to 1->2->4->5

If there are even nodes, then there would be two middle nodes, we need to delete the second middle element. For example, if given linked list is 1->2->3->4->5->6 then it should be modified to 1->2->3->5->6.
If the input linked list is NULL, then it should remain NULL.

If the input linked list has 1 node, then this node should be deleted and a new head should be returned. 

Simple solution: The idea is to first count the number of nodes in a linked list, then delete n/2’th node using the simple deletion process. 

Python3




# Python3 program to delete middle
# of a linked list
   
# Link list Node 
class Node:    
    def __init__(self):        
        self.data = 0
        self.next = None
      
# Count of nodes
def countOfNodes(head):
    count = 0    
    while (head != None):
        head = head.next
        count += 1
      
    return count
  
# Deletes middle node and returns
# head of the modified list
def deleteMid(head):
  
    # Base cases
    if (head == None):
        return None
    if (head.next == None):
        del head
        return None
  
    copyHead = head
   
    # Find the count of nodes
    count = countOfNodes(head)
   
    # Find the middle node
    mid = count // 2
   
    # Delete the middle node
    while (mid > 1):
        mid -= 1
        head = head.next
   
    # Delete the middle node
    head.next = head.next.next
   
    return copyHead
  
# A utility function to print
# a given linked list
def printList(ptr):
    while (ptr != None):
        print(ptr.data, 
              end = '->')
        ptr = ptr.next
      
    print('NULL')
      
# Utility function to create 
# a new node.
def newNode(data):
    temp = Node()
    temp.data = data
    temp.next = None
    return temp
  
# Driver Code
if __name__=='__main__':
      
    # Start with the empty list
    head = newNode(1)
    head.next = newNode(2)
    head.next.next = newNode(3)
    head.next.next.next = newNode(4)
   
    print("Given Linked List")
    printList(head)
   
    head = deleteMid(head)
   
    print("Linked List after deletion of middle")
    printList(head)
  
# This code is contributed by rutvik_56

Output:

Given Linked List
1->2->3->4->NULL
Linked List after deletion of middle
1->2->4->NULL

Complexity Analysis: 

  • Time Complexity: O(n). 
    Two traversals of the linked list is needed
  • Auxiliary Space: O(1). 
    No extra space is needed.

Efficient solution: 
Approach: The above solution requires two traversals of the linked list. The middle node can be deleted using one traversal. The idea is to use two pointers, slow_ptr, and fast_ptr. Both pointers start from the head of list. When fast_ptr reaches the end, slow_ptr reaches middle. This idea is same as the one used in method 2 of this post. The additional thing in this post is to keep track of the previous middle so the middle node can be deleted.

Below is the implementation.

Python3




# Python3 program to delete the
# middle of a linked list
  
# Linked List Node
class Node:    
    def __init__(self, data):
        self.data = data
        self.next = None
  
# Create and handle list 
# operations
class LinkedList:    
    def __init__(self):
          
        # Head of the list
        self.head = None 
  
    # Add new node to the list end
    def addToList(self, data):        
        newNode = Node(data)
        if self.head is None:
            self.head = newNode
            return
              
        last = self.head
          
        while last.next:
            last = last.next
              
        last.next = newNode
  
    # Returns the list in string 
    # format
    def __str__(self):        
        linkedListStr = ""
        temp = self.head
          
        while temp:
            linkedListStr += str(temp.data) + "->"
            temp = temp.next
              
        return linkedListStr + "NULL"
  
    # Method deletes middle node
    def deleteMid(self):
  
        # Base cases
        if (self.head is None or 
            self.head.next is None):
            return
  
        # Initialize slow and fast pointers
        # to reach middle of linked list
        slow_Ptr = self.head
        fast_Ptr = self.head
  
        # Find the middle and previous of 
        # middle
        prev = None
  
        # To store previous of slow pointer
        while (fast_Ptr is not None and 
               fast_Ptr.next is not None):
            fast_Ptr = fast_Ptr.next.next
            prev = slow_Ptr
            slow_Ptr = slow_Ptr.next
  
        # Delete the middle node
        prev.next = slow_Ptr.next
  
# Driver code
linkedList = LinkedList()
  
linkedList.addToList(1)
linkedList.addToList(2)
linkedList.addToList(3)
linkedList.addToList(4)
  
print("Given Linked List")
print(linkedList)
  
linkedList.deleteMid()
  
print("Linked List after deletion of middle")
print(linkedList)
# This code is contributed by Debidutta Rath

Output:

Given Linked List
1->2->3->4->NULL
Linked List after deletion of middle
1->2->4->NULL

Complexity Analysis: 

  • Time Complexity: O(n). 
    Only one traversal of the linked list is needed
  • Auxiliary Space: O(1). 
    As no extra space is needed.

Please refer complete article on Delete middle of linked list for more details!


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!