Java Program To Delete Middle Of Linked List

Last Updated : 30 Dec, 2021
Comments
Improve
Suggest changes
Like Article
Like
Report

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

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

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!

Next Article
Java Program To Delete Middle Of Linked List
author
kartik
Improve
Article Tags :
Practice Tags :

Similar Reads