Java Program For Deleting Last Occurrence Of An Item From Linked List

Last Updated : 22 Jun, 2022

Using pointers, loop through the whole list and keep track of the node prior to the node containing the last occurrence key using a special pointer. After this just store the next of next of the special pointer, into to next of special pointer to remove the required node from the linked list.

Java

// Java program to implement 
// the above approach
import java.io.*;
 
// A linked list Node
class Node
{
    int data; 
    Node next;
    
    Node(int data)
    {
        this.data = data;
        this.next = null;
    }
}

class GFG{

// Function to delete the last 
// occurrence
static Node deleteLast(Node head,
                       int x)
{
    Node temp = head;
    Node ptr = null;
    
    while (temp != null)
    {        
        // If found key, update
        if (temp.data == x)
            ptr = temp;
            
        temp = temp.next;
    }
  
    // If the last occurrence is the 
    // last node
    if (ptr != null && 
        ptr.next == null)
    {
        temp = head;
        
        while (temp.next != ptr)
        {
            temp = temp.next;
        }
        temp.next = null;
    }
    
    // If it is not the last node
    if (ptr != null && 
        ptr.next != null)
    {
        ptr.data = ptr.next.data;
        temp = ptr.next;
        ptr.next = ptr.next.next;
    }
    return head;
}

// This function prints contents of 
// linked list starting from the given 
// Node
static void display(Node head)
{
    Node temp = head;
    if (head == null)
    {
        System.out.print("NULL");
        return;
    }
    while (temp != null)
    {
        System.out.print(temp.data + 
                         " --> ");
        temp = temp.next;
    }
    System.out.print("NULL");
}

// Driver code
public static void main(String[] args)
{
    Node head = new Node(1);
    head.next = new Node(2);
    head.next.next = new Node(3);
    head.next.next.next = 
    new Node(4);
    head.next.next.next.next = 
    new Node(5);
    head.next.next.next.next.next = 
    new Node(4);
    head.next.next.next.next.next.next = 
    new Node(4);
    
    System.out.print(
           "Created Linked list: ");
    display(head);
    
    // Pass the address of the head 
    // pointer
    head = deleteLast(head, 4);
    System.out.print(
           "List after deletion of 4: ");
    display(head);
}
}
// This code is contributed by patel2127

Output:

Created Linked list: 1 --> 2 --> 3 --> 4 --> 5 --> 4 --> 4 --> NULL
List after deletion of 4: 1 --> 2 --> 3 --> 4 --> 5 --> 4 --> NULL

Time Complexity: O(n) where n is the number of nodes in the given linked list.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

Given a linked list and a key to be deleted. Delete last occurrence of key from linked. The list may have duplicates.

Examples:

Input:   1->2->3->5->2->10, key = 2
Output:  1->2->3->5->10

The idea is to traverse the linked list from beginning to end. While traversing, keep track of last occurrence key. After traversing the complete list, delete the last occurrence by copying data of next node and deleting the next node.

Java

// A Java program to demonstrate deletion 
// of last Node in singly linked list 
class GFG{
    
// A linked list Node 
static class Node 
{ 
    int key; 
    Node next; 
}; 

static Node deleteLast(Node head, 
                       int key) 
{ 
    // Initialize previous of Node to 
    // be deleted 
    Node x = null; 

    // Start from head and find the Node 
    // to be deleted 
    Node temp = head; 
    while (temp != null) 
    { 
        // If we found the key, 
        // update xv 
        if (temp.key == key) 
            x = temp; 

        temp = temp.next; 
    } 

    // Key occurs at-least once 
    if (x != null) 
    { 
        // Copy key of next Node to x 
        x.key = x.next.key; 

        // Store and unlink next 
        temp = x.next; 
        x.next = x.next.next; 

        // Free memory for next 
    } 
    return head;
} 

// Utility function to create a 
// new node with given key 
static Node newNode(int key) 
{ 
    Node temp = new Node(); 
    temp.key = key; 
    temp.next = null; 
    return temp; 
} 

// This function prints contents of 
// linked list starting from the given 
// Node 
static void printList( Node node) 
{ 
    while (node != null) 
    { 
        System.out.printf(" %d ", 
                          node.key); 
        node = node.next; 
    } 
} 

// 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(5); 
    head.next.next.next.next = 
    newNode(2); 
    head.next.next.next.next.next = 
    newNode(10); 

    System.out.printf("Created Linked List: "); 
    printList(head); 
    deleteLast(head, 2); 
    System.out.printf(
           "Linked List after Deletion of 1: "); 
    printList(head); 
}
} 
// This code is contributed by Arnab Kundu

Output:

Created Linked List: 
1  2  3  5  2  10 
Linked List after Deletion of 1: 
1  2  3  5  10

Time Complexity: O(n) where n is the number of nodes in the given linked list.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

The above solution doesn't work when the node to be deleted is the last node.
Following solution handles all cases.

Java

// Java program to demonstrate deletion 
// of last Node in singly linked list 
class GFG{

// A linked list Node 
static class Node 
{ 
    int data; 
    Node next; 
}; 

// Function to delete the last 
// occurrence 
static void deleteLast(Node head, 
                       int x) 
{ 
    Node temp = head, ptr = null; 
    while (temp!=null) 
    { 
        // If found key, update 
        if (temp.data == x) 
            ptr = temp;     
        temp = temp.next; 
    } 

    // If the last occurrence is the 
    // last node 
    if (ptr != null && 
        ptr.next == null) 
    { 
        temp = head; 
        while (temp.next != ptr) 
            temp = temp.next; 
        temp.next = null; 
    } 

    // If it is not the last node 
    if (ptr != null && 
        ptr.next != null)
    { 
        ptr.data = ptr.next.data; 
        temp = ptr.next; 
        ptr.next = ptr.next.next; 
        System.gc();
    } 
} 

/* Utility function to create a 
   new node with given key */
static Node newNode(int x) 
{ 
    Node node = new Node(); 
    node.data = x; 
    node.next = null; 
    return node; 
} 

// This function prints contents 
// of linked list starting from 
// the given Node 
static void display(Node head) 
{ 
    Node temp = head; 
    if (head == null) 
    { 
        System.out.print("null"); 
        return; 
    } 
    while (temp != null) 
    { 
        System.out.printf("%d --> ", 
                          temp.data); 
        temp = temp.next; 
    } 
    System.out.print("null"); 
} 

// Driver code
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); 
    head.next.next.next.next = 
    newNode(5); 
    head.next.next.next.next.next = 
    newNode(4); 
    head.next.next.next.next.next.next = 
    newNode(4); 
    System.out.print(
    "Created Linked list: "); 
    display(head); 
    deleteLast(head, 4); 
    System.out.print(
    "List after deletion of 4: "); 
    display(head); 
}
}
// This code is contributed by PrinciRaj1992

Output:

Created Linked List: 
1  2  3  4  5  4  4 
Linked List after Deletion of 1: 
1  2  3  4  5  4

Time Complexity: O(n) where n is the number of nodes in the given linked list.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

Please refer complete article on Delete last occurrence of an item from linked list for more details!