Open In App

# Python Program To Delete Middle Of Linked List

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!