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