Delete middle of linked list
Last Updated :
10 Jan, 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.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
struct Node* next;
};
int countOfNodes( struct Node* head)
{
int count = 0;
while (head != NULL) {
head = head->next;
count++;
}
return count;
}
struct Node* deleteMid( struct Node* head)
{
if (head == NULL)
return NULL;
if (head->next == NULL) {
delete head;
return NULL;
}
struct Node* copyHead = head;
int count = countOfNodes(head);
int mid = count / 2;
while (mid-- > 1)
head = head->next;
head->next = head->next->next;
return copyHead;
}
void printList( struct Node* ptr)
{
while (ptr != NULL) {
cout << ptr->data << "->" ;
ptr = ptr->next;
}
cout << "NULL\n" ;
}
Node* newNode( int data)
{
struct Node* temp = new Node;
temp->data = data;
temp->next = NULL;
return temp;
}
int main()
{
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;
}
|
C
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int data;
struct Node* next;
} Node;
int countOfNodes(Node* head)
{
int count = 0;
while (head != NULL) {
head = head->next;
count++;
}
return count;
}
Node* deleteMid(Node* head)
{
if (head == NULL)
return NULL;
if (head->next == NULL) {
free (head);
return NULL;
}
Node* copyHead = head;
int count = countOfNodes(head);
int mid = count / 2;
while (mid-->1)
head = head->next;
head->next = head->next->next;
return copyHead;
}
void printList(Node* ptr)
{
while (ptr != NULL) {
printf ( "%d ->" , ptr->data);
ptr = ptr->next;
}
printf ( "NULL\n" );
}
Node* newNode( int data)
{
Node* temp = (Node*) malloc ( sizeof (Node));
temp->data = data;
temp->next = NULL;
return temp;
}
int main()
{
Node* head = newNode(1);
head->next = newNode(2);
head->next->next = newNode(3);
head->next->next->next = newNode(4);
printf ( "Given Linked List\n" );
printList(head);
head = deleteMid(head);
printf ( "Linked List after deletion of middle\n" );
printList(head);
return 0;
}
|
Java
import java.io.*;
class GFG {
static class Node {
int data;
Node next;
}
static Node newNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.next = null ;
return temp;
}
static int countOfNodes(Node head)
{
int count = 0 ;
while (head != null ) {
head = head.next;
count++;
}
return count;
}
static Node deleteMid(Node head)
{
if (head == null )
return null ;
if (head.next == null ) {
return null ;
}
Node copyHead = head;
int count = countOfNodes(head);
int mid = count / 2 ;
while (mid-- > 1 ) {
head = head.next;
}
head.next = head.next.next;
return copyHead;
}
static void printList(Node ptr)
{
while (ptr != null ) {
System.out.print(ptr.data + "->" );
ptr = ptr.next;
}
System.out.println( "NULL" );
}
public static void main(String[] args)
{
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);
}
}
|
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)
|
C#
using System;
class GfG {
class Node {
public int data;
public Node next;
}
static int countOfNodes(Node head)
{
int count = 0;
while (head != null ) {
head = head.next;
count++;
}
return count;
}
static Node deleteMid(Node head)
{
if (head == null )
return null ;
if (head.next == null ) {
return null ;
}
Node copyHead = head;
int count = countOfNodes(head);
int mid = count / 2;
while (mid-- > 1) {
head = head.next;
}
head.next = head.next.next;
return copyHead;
}
static void printList(Node ptr)
{
while (ptr != null ) {
Console.Write(ptr.data + "->" );
ptr = ptr.next;
}
Console.WriteLine( "NULL" );
}
static Node newNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.next = null ;
return temp;
}
public static void Main(String[] args)
{
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);
}
}
|
Javascript
<script>
class Node {
constructor() {
this .data = 0;
this .next = null ;
}
}
function countOfNodes(head)
{
let count = 0;
while (head != null ) {
head = head.next;
count+=1;
}
return count;
}
function deleteMid(head)
{
if (head == null )
return null ;
if (head.next == null ) {
return null ;
}
var copyHead = head;
var count = countOfNodes(head);
var mid = parseInt(count / 2);
while (mid-- > 1) {
head = head.next;
}
head.next = head.next.next;
return copyHead;
}
function printList( ptr) {
while (ptr != null ) {
document.write(ptr.data + "->" );
ptr = ptr.next;
}
document.write( "NULL<br/>" );
}
function newNode(data) {
temp = new Node();
temp.data = data;
temp.next = null ;
return temp;
}
head = newNode(1);
head.next = newNode(2);
head.next.next = newNode(3);
head.next.next.next = newNode(4);
document.write( "Given Linked List<br/>" );
printList(head);
head = deleteMid(head);
document.write(
"Linked List after deletion of middle<br/>"
);
printList(head);
</script>
|
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 are 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 the 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++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
struct Node* next;
};
struct Node* deleteMid( struct Node* head)
{
if (head == NULL)
return NULL;
if (head->next == NULL) {
delete head;
return NULL;
}
struct Node* slow_ptr = head;
struct Node* fast_ptr = head;
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;
}
prev->next = slow_ptr->next;
delete slow_ptr;
return head;
}
void printList( struct Node* ptr)
{
while (ptr != NULL) {
cout << ptr->data << "->" ;
ptr = ptr->next;
}
cout << "NULL\n" ;
}
Node* newNode( int data)
{
struct Node* temp = new Node;
temp->data = data;
temp->next = NULL;
return temp;
}
int main()
{
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
class GfG {
static class Node {
int data;
Node next;
}
static Node deleteMid(Node head)
{
if (head == null )
return null ;
if (head.next == null ) {
return null ;
}
Node slow_ptr = head;
Node fast_ptr = head;
Node prev = null ;
while (fast_ptr != null
&& fast_ptr.next != null ) {
fast_ptr = fast_ptr.next.next;
prev = slow_ptr;
slow_ptr = slow_ptr.next;
}
prev.next = slow_ptr.next;
return head;
}
static void printList(Node ptr)
{
while (ptr != null ) {
System.out.print(ptr.data + "->" );
ptr = ptr.next;
}
System.out.println( "NULL" );
}
static Node newNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.next = null ;
return temp;
}
public static void main(String[] args)
{
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);
}
}
|
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)
|
C#
using System;
class GfG {
class Node {
public int data;
public Node next;
}
static Node deleteMid(Node head)
{
if (head == null )
return null ;
if (head.next == null ) {
return null ;
}
Node slow_ptr = head;
Node fast_ptr = head;
Node prev = null ;
while (fast_ptr != null && fast_ptr.next != null ) {
fast_ptr = fast_ptr.next.next;
prev = slow_ptr;
slow_ptr = slow_ptr.next;
}
prev.next = slow_ptr.next;
return head;
}
static void printList(Node ptr)
{
while (ptr != null ) {
Console.Write(ptr.data + "->" );
ptr = ptr.next;
}
Console.WriteLine( "NULL" );
}
static Node newNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.next = null ;
return temp;
}
public static void Main(String[] args)
{
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);
}
}
|
Javascript
<script>
class Node {
constructor() {
this .data = 0;
this .next = null ;
}
}
function deleteMid( head) {
if (head == null )
return null ;
if (head.next == null ) {
return null ;
}
var slow_ptr = head;
var fast_ptr = head;
var prev = null ;
while (fast_ptr != null && fast_ptr.next != null )
{
fast_ptr = fast_ptr.next.next;
prev = slow_ptr;
slow_ptr = slow_ptr.next;
}
prev.next = slow_ptr.next;
return head;
}
function printList( ptr) {
while (ptr != null ) {
document.write(ptr.data + "->" );
ptr = ptr.next;
}
document.write( "NULL<br/>" );
}
function newNode(data) {
temp = new Node();
temp.data = data;
temp.next = null ;
return temp;
}
head = newNode(1);
head.next = newNode(2);
head.next.next = newNode(3);
head.next.next.next = newNode(4);
document.write( "Given Linked List<br/>" );
printList(head);
head = deleteMid(head);
document.write(
"Linked List after deletion of middle<br/>"
);
printList(head);
</script>
|
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.
Share your thoughts in the comments
Please Login to comment...