Java Program To Delete Middle Of Linked List
Last Updated :
30 Dec, 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.Â
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);
}
}
|
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. Â
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);
}
}
|
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!
Share your thoughts in the comments
Please Login to comment...