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
import java.io.*;
class Node
{
int data;
Node next;
Node( int data)
{
this .data = data;
this .next = null ;
}
}
class GFG{
static Node deleteLast(Node head,
int x)
{
Node temp = head;
Node ptr = null ;
while (temp != null )
{
if (temp.data == x)
ptr = temp;
temp = temp.next;
}
if (ptr != null &&
ptr.next == null )
{
temp = head;
while (temp.next != ptr)
{
temp = temp.next;
}
temp.next = null ;
}
if (ptr != null &&
ptr.next != null )
{
ptr.data = ptr.next.data;
temp = ptr.next;
ptr.next = ptr.next.next;
}
return head;
}
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" );
}
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);
head = deleteLast(head, 4 );
System.out.print(
"List after deletion of 4: " );
display(head);
}
}
|
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
class GFG{
static class Node
{
int key;
Node next;
};
static Node deleteLast(Node head,
int key)
{
Node x = null ;
Node temp = head;
while (temp != null )
{
if (temp.key == key)
x = temp;
temp = temp.next;
}
if (x != null )
{
x.key = x.next.key;
temp = x.next;
x.next = x.next.next;
}
return head;
}
static Node newNode( int key)
{
Node temp = new Node();
temp.key = key;
temp.next = null ;
return temp;
}
static void printList( Node node)
{
while (node != null )
{
System.out.printf( " %d " ,
node.key);
node = node.next;
}
}
public static void main(String args[])
{
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);
}
}
|
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
class GFG{
static class Node
{
int data;
Node next;
};
static void deleteLast(Node head,
int x)
{
Node temp = head, ptr = null ;
while (temp!= null )
{
if (temp.data == x)
ptr = temp;
temp = temp.next;
}
if (ptr != null &&
ptr.next == null )
{
temp = head;
while (temp.next != ptr)
temp = temp.next;
temp.next = null ;
}
if (ptr != null &&
ptr.next != null )
{
ptr.data = ptr.next.data;
temp = ptr.next;
ptr.next = ptr.next.next;
System.gc();
}
}
static Node newNode( int x)
{
Node node = new Node();
node.data = x;
node.next = null ;
return 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" );
}
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);
}
}
|
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!
Share your thoughts in the comments
Please Login to comment...