Python Program To Delete Middle Of Linked List
Last Updated :
18 Aug, 2023
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
class Node:
def __init__( self ):
self .data = 0
self . next = None
def countOfNodes(head):
count = 0
while (head ! = None ):
head = head. next
count + = 1
return count
def deleteMid(head):
if (head = = None ):
return None
if (head. next = = None ):
del head
return None
copyHead = head
count = countOfNodes(head)
mid = count / / 2
while (mid > 1 ):
mid - = 1
head = head. next
head. next = head. next . next
return copyHead
def printList(ptr):
while (ptr ! = None ):
print (ptr.data,
end = '->' )
ptr = ptr. next
print ( 'NULL' )
def newNode(data):
temp = Node()
temp.data = data
temp. next = None
return temp
if __name__ = = '__main__' :
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)
|
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
class Node:
def __init__( self , data):
self .data = data
self . next = None
class LinkedList:
def __init__( self ):
self .head = None
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
def __str__( self ):
linkedListStr = ""
temp = self .head
while temp:
linkedListStr + = str (temp.data) + "->"
temp = temp. next
return linkedListStr + "NULL"
def deleteMid( self ):
if ( self .head is None or
self .head. next is None ):
return
slow_Ptr = self .head
fast_Ptr = self .head
prev = None
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
prev. next = slow_Ptr. next
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)
|
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!
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...