Related Articles

# Delete middle of linked list

• Difficulty Level : Easy
• Last Updated : 10 Sep, 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.

## C++14

 `// C++ program to delete middle``// of a linked list``#include ``using` `namespace` `std;` `/* Link list Node */``struct` `Node {``    ``int` `data;``    ``struct` `Node* next;``};``// count of nodes``int` `countOfNodes(``struct` `Node* head)``{``    ``int` `count = 0;``    ``while` `(head != NULL) {``        ``head = head->next;``        ``count++;``    ``}``    ``return` `count;``}` `// Deletes middle node and returns``// head of the modified list``struct` `Node* deleteMid(``struct` `Node* head)``{``    ``// Base cases``    ``if` `(head == NULL)``        ``return` `NULL;``    ``if` `(head->next == NULL) {``        ``delete` `head;``        ``return` `NULL;``    ``}``    ``struct` `Node* copyHead = head;` `    ``// Find the count of nodes``    ``int` `count = countOfNodes(head);` `    ``// Find the middle node``    ``int` `mid = count / 2;` `    ``// Delete the middle node``    ``while` `(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``void` `printList(``struct` `Node* ptr)``{``    ``while` `(ptr != NULL) {``        ``cout << ptr->data << ``"->"``;``        ``ptr = ptr->next;``    ``}``    ``cout << ``"NULL\n"``;``}` `// Utility function to create a new node.``Node* newNode(``int` `data)``{``    ``struct` `Node* temp = ``new` `Node;``    ``temp->data = data;``    ``temp->next = NULL;``    ``return` `temp;``}` `/* Driver program to test above function*/``int` `main()``{``    ``/* Start with the empty list */``    ``struct` `Node* head = newNode(1);``    ``head->next = newNode(2);``    ``head->next->next = newNode(3);``    ``head->next->next->next = newNode(4);` `    ``cout << ``"Given Linked List\n"``;``    ``printList(head);` `    ``head = deleteMid(head);` `    ``cout << ``"Linked List after deletion of middle\n"``;``    ``printList(head);` `    ``return` `0;``}`

## Java

 `// Java program to delete middle``// of a linked list``import` `java.io.*;` `class` `GFG {` `    ``/* Link list Node */``    ``static` `class` `Node {``        ``int` `data;``        ``Node next;``    ``}` `    ``// Utility function to create a new node.``    ``static` `Node newNode(``int` `data)``    ``{``        ``Node temp = ``new` `Node();``        ``temp.data = data;``        ``temp.next = ``null``;``        ``return` `temp;``    ``}` `    ``// count of nodes``    ``static` `int` `countOfNodes(Node head)``    ``{``        ``int` `count = ``0``;``        ``while` `(head != ``null``) {``            ``head = head.next;``            ``count++;``        ``}``        ``return` `count;``    ``}` `    ``// Deletes middle node and returns``    ``// head of the modified list``    ``static` `Node deleteMid(Node head)``    ``{``        ``// Base cases``        ``if` `(head == ``null``)``            ``return` `null``;``        ``if` `(head.next == ``null``) {``            ``return` `null``;``        ``}``        ``Node copyHead = head;` `        ``// Find the count of nodes``        ``int` `count = countOfNodes(head);` `        ``// Find the middle node``        ``int` `mid = count / ``2``;` `        ``// Delete the middle node``        ``while` `(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``    ``static` `void` `printList(Node ptr)``    ``{``        ``while` `(ptr != ``null``) {``            ``System.out.print(ptr.data + ``"->"``);``            ``ptr = ptr.next;``        ``}``        ``System.out.println(``"NULL"``);``    ``}` `    ``/* Driver code*/``    ``public` `static` `void` `main(String[] args)``    ``{``        ``/* Start with the empty list */``        ``Node head = newNode(``1``);``        ``head.next = newNode(``2``);``        ``head.next.next = newNode(``3``);``        ``head.next.next.next = newNode(``4``);` `        ``System.out.println(``"Given Linked List"``);``        ``printList(head);` `        ``head = deleteMid(head);` `        ``System.out.println(``            ``"Linked List after deletion of middle"``);``        ``printList(head);``    ``}``}` `// This code is contributed by rajsanghavi9.`

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

## C++

 `// C++ program to delete middle``// of a linked list``#include ``using` `namespace` `std;` `/* Link list Node */``struct` `Node {``    ``int` `data;``    ``struct` `Node* next;``};` `// Deletes middle node and returns``// head of the modified list``struct` `Node* deleteMid(``struct` `Node* head)``{``    ``// Base cases``    ``if` `(head == NULL)``        ``return` `NULL;``    ``if` `(head->next == NULL) {``        ``delete` `head;``        ``return` `NULL;``    ``}` `    ``// Initialize slow and fast pointers``    ``// to reach middle of linked list``    ``struct` `Node* slow_ptr = head;``    ``struct` `Node* fast_ptr = head;` `    ``// Find the middle and previous of middle.``// To store previous of slow_ptr   ``struct` `Node* prev;``    ``while` `(fast_ptr != NULL``&& fast_ptr->next != NULL) {``        ``fast_ptr = fast_ptr->next->next;``        ``prev = slow_ptr;``        ``slow_ptr = slow_ptr->next;``    ``}` `    ``// Delete the middle node``    ``prev->next = slow_ptr->next;``    ``delete` `slow_ptr;` `    ``return` `head;``}` `// A utility function to print``// a given linked list``void` `printList(``struct` `Node* ptr)``{``    ``while` `(ptr != NULL) {``        ``cout << ptr->data << ``"->"``;``        ``ptr = ptr->next;``    ``}``    ``cout << ``"NULL\n"``;``}` `// Utility function to create a new node.``Node* newNode(``int` `data)``{``    ``struct` `Node* temp = ``new` `Node;``    ``temp->data = data;``    ``temp->next = NULL;``    ``return` `temp;``}` `/* Driver program to test above function*/``int` `main()``{``    ``/* Start with the empty list */``    ``struct` `Node* head = newNode(1);``    ``head->next = newNode(2);``    ``head->next->next = newNode(3);``    ``head->next->next->next = newNode(4);` `    ``cout << ``"Given Linked List\n"``;``    ``printList(head);` `    ``head = deleteMid(head);` `    ``cout << ``"Linked List after deletion of middle\n"``;``    ``printList(head);` `    ``return` `0;``}`

## Java

 `// Java program to delete the``// middle of a linked list``class` `GfG {` `    ``/* Link list Node */``    ``static` `class` `Node {``        ``int` `data;``        ``Node next;``    ``}` `    ``// Deletes middle node and returns``    ``// head of the modified list``    ``static` `Node deleteMid(Node head)``    ``{``        ``// Base cases``        ``if` `(head == ``null``)``            ``return` `null``;``        ``if` `(head.next == ``null``) {``            ``return` `null``;``        ``}` `        ``// Initialize slow and fast pointers``        ``// to reach middle of linked list``        ``Node slow_ptr = head;``        ``Node fast_ptr = head;` `        ``// Find the middle and previous of middle.``        ``Node prev = ``null``;` `        ``// To store previous of slow_ptr``        ``while` `(fast_ptr != ``null``&& fast_ptr.next != ``null``) {``            ``fast_ptr = fast_ptr.next.next;``            ``prev = slow_ptr;``            ``slow_ptr = slow_ptr.next;``        ``}` `        ``// Delete the middle node``        ``prev.next = slow_ptr.next;` `        ``return` `head;``    ``}` `    ``// A utility function to print``// a given linked list``    ``static` `void` `printList(Node ptr)``    ``{``        ``while` `(ptr != ``null``) {``            ``System.out.print(ptr.data + ``"->"``);``            ``ptr = ptr.next;``        ``}``        ``System.out.println(``"NULL"``);``    ``}` `    ``// Utility function to create a new node.``    ``static` `Node newNode(``int` `data)``    ``{``        ``Node temp = ``new` `Node();``        ``temp.data = data;``        ``temp.next = ``null``;``        ``return` `temp;``    ``}` `    ``/* Driver code*/``    ``public` `static` `void` `main(String[] args)``    ``{``        ``/* Start with the empty list */``        ``Node head = newNode(``1``);``        ``head.next = newNode(``2``);``        ``head.next.next = newNode(``3``);``        ``head.next.next.next = newNode(``4``);` `        ``System.out.println(``"Given Linked List"``);``        ``printList(head);` `        ``head = deleteMid(head);` `        ``System.out.println(``"Linked List after deletion of middle"``);``        ``printList(head);``    ``}``}` `// This code is contributed by Prerna saini.`

## 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`

## C#

 `// C# program to delete middle of a linked list``using` `System;` `class` `GfG {` `    ``/* Link list Node */``    ``class` `Node {``        ``public` `int` `data;``        ``public` `Node next;``    ``}` `    ``// Deletes middle node and returns``    ``// head of the modified list``    ``static` `Node deleteMid(Node head)``    ``{``        ``// Base cases``        ``if` `(head == ``null``)``            ``return` `null``;``        ``if` `(head.next == ``null``) {``            ``return` `null``;``        ``}` `        ``// Initialize slow and fast pointers``        ``// to reach middle of linked list``        ``Node slow_ptr = head;``        ``Node fast_ptr = head;` `        ``// Find the middle and previous of middle.``        ``Node prev = ``null``;` `        ``// To store previous of slow_ptr``        ``while` `(fast_ptr != ``null` `&& fast_ptr.next != ``null``) {``            ``fast_ptr = fast_ptr.next.next;``            ``prev = slow_ptr;``            ``slow_ptr = slow_ptr.next;``        ``}` `        ``// Delete the middle node``        ``prev.next = slow_ptr.next;` `        ``return` `head;``    ``}` `    ``// A utility function to print``    ``// a given linked list``    ``static` `void` `printList(Node ptr)``    ``{``        ``while` `(ptr != ``null``) {``            ``Console.Write(ptr.data + ``"->"``);``            ``ptr = ptr.next;``        ``}``        ``Console.WriteLine(``"NULL"``);``    ``}` `    ``// Utility function to create a new node.``    ``static` `Node newNode(``int` `data)``    ``{``        ``Node temp = ``new` `Node();``        ``temp.data = data;``        ``temp.next = ``null``;``        ``return` `temp;``    ``}` `    ``/* Driver code*/``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``/* Start with the empty list */``        ``Node head = newNode(1);``        ``head.next = newNode(2);``        ``head.next.next = newNode(3);``        ``head.next.next.next = newNode(4);` `        ``Console.WriteLine(``"Given Linked List"``);``        ``printList(head);` `        ``head = deleteMid(head);` `        ``Console.WriteLine(``"Linked List after"``                          ``+ ``"deletion of middle"``);``        ``printList(head);``    ``}``}` `/* This code is contributed by 29AjayKumar */`

## Javascript

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

-7rw?list=PLqM7alHXFySH41ZxzrPNj2pAYPOI8ITe7
This article is contributed by Piyush Gupta. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.