Delete last occurrence of an item from linked list

Difficulty Level : Medium
Last Updated : 20 Jul, 2021

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.

C++

#include <iostream>
#include <bits/stdc++.h>
using namespace std;
 
// A linked list Node
struct Node
{
    int data;
    struct Node* next;
};
 
// Function to delete the last occurrence
void deleteLast(struct Node** head, int x)
{
    struct Node** tmp1 = NULL;
    while (*head)
    {
            if ((*head)->data == x)
            {
                tmp1 = head;
            }
            head = &(*head)->next;
    }
    if (tmp1)
    {
        struct Node* tmp = *tmp1;
        *tmp1 = tmp->next;
        free(tmp);
    }
}
 
// Utility function to create a new node with
// given key
struct 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
void display(struct Node* head)
{
    struct Node* temp = head;
    if (head == NULL)
    {
        cout << "NULL\n";
        return;
    }
    while (temp != NULL)
    {
        cout << temp->data <<" --> ";
        temp = temp->next;
    }
    cout << "NULL\n";
}
 
// Driver code
int main()
{
    struct 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);
     
    cout << "Created Linked list: ";
    display(head);
     
    // Pass the address of the head pointer
    deleteLast(&head, 4);  
    cout << "List after deletion of 4: ";
     
    display(head);
     
    return 0;
}
 
// This code is contributed by khushboogoyal499

C

#include <stdio.h>
#include <stdlib.h>
 
// A linked list Node
struct Node {
    int data;
    struct Node* next;
};
 
// Function to delete the last occurrence
void deleteLast(struct Node** head, int x)
{
        struct Node** tmp1 = NULL;
        while(*head) {
                if((*head)->data == x) {
                        tmp1 = head;
                }
                head = &(*head)->next;
        }
        if(tmp1) {
                struct Node* tmp = *tmp1;
                *tmp1 = tmp->next;
                free(tmp);
        }
}
 
/* Utility function to create a new node with
given key */
struct Node* newNode(int x)
{
    struct Node* node = malloc(sizeof(struct Node*));
    node->data = x;
    node->next = NULL;
    return node;
}
 
// This function prints contents of linked list
// starting from the given Node
void display(struct Node* head)
{
    struct Node* temp = head;
    if (head == NULL) {
        printf("NULL\n");
        return;
    }
    while (temp != NULL) {
        printf("%d --> ", temp->data);
        temp = temp->next;
    }
    printf("NULL\n");
}
 
/* Driver program to test above functions*/
int main()
{
    struct 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);
    printf("Created Linked list: ");
    display(head);
    deleteLast(&head, 4);   // Pass the address of the head pointer
    printf("List after deletion of 4: ");
    display(head);
    return 0;
}

Java

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\n");
        return;
    }
    while (temp != null)
    {
        System.out.print( temp.data+" --> ");
        temp = temp.next;
    }
    System.out.print("NULL\n");
}
 
// 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

Python3

# A linked list Node
class Node:
    def __init__(self, new_data):
         
        self.data = new_data
        self.next = None
 
# Function to delete the last occurrence
def deleteLast(head, x):
 
    temp = head
    ptr = None
     
    while (temp != None):
         
        # If found key, update
        if (temp.data == x):
            ptr = temp    
             
        temp = temp.next
     
    # If the last occurrence is the last node
    if (ptr != None and ptr.next == None):
        temp = head
        while (temp.next != ptr):
            temp = temp.next
             
        temp.next = None
     
    # If it is not the last node
    if (ptr != None and ptr.next != None):
        ptr.data = ptr.next.data
        temp = ptr.next
        ptr.next = ptr.next.next
         
    return head
     
# Utility function to create a new node
# with given key
def newNode(x):
 
    node = Node(0)
    node.data = x
    node.next = None
    return node
 
# This function prints contents of linked
# list starting from the given Node
def display(head):
 
    temp = head
     
    if (head == None):
        print("NULL\n")
        return
     
    while (temp != None):
        print( temp.data," --> ", end = "")
        temp = temp.next
     
    print("NULL")
 
# Driver code
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)
 
print("Created Linked list: ", end = '')
display(head)
 
# Pass the address of the head pointer
head = deleteLast(head, 4)
print("List after deletion of 4: ", end = '')
 
display(head)
 
# This code is contributed by rutvik_56

Javascript

<script>
// A linked list Node
class Node
{
 
    // Utility function to create a new node
    // with given key
    constructor(data)
    {
        this.data = data;
        this.next = null;
        
    }
}
 
// Function to delete the last occurrence
function deleteLast(head, x)
{
    let temp = head;
    let prt = 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
function display(head)
{
    let temp = head
    if (head == null)
    {
        document.write("NULL<br>");
        return;
    }
    while (temp != null)
    {
        document.write( temp.data," --> ", end = "");
        temp = temp.next;
    }
    document.write("NULL<br>")
}
 
// Driver code
let 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);
 
document.write("Created Linked list: ");
display(head)
 
// Pass the address of the head pointer
head = deleteLast(head, 4)
document.write("List after deletion of 4: ")
display(head)
 
// This code is contributed by avanitrachhadiya2155
</script>

Output

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

Given a liked 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.

C++

// A C++ program to demonstrate deletion of last
// Node in singly linked list
#include <bits/stdc++.h>
 
// A linked list Node
struct Node {
    int key;
    struct Node* next;
};
 
void 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) {
        // 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
        delete temp;
    }
}
 
/* Utility function to create a new node with
   given key */
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
void printList(struct Node* node)
{
    while (node != NULL) {
        printf(" %d ", node->key);
        node = node->next;
    }
}
 
/* Driver program to test above functions*/
int main()
{
    /* Start with the empty list */
    struct 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);
 
    puts("Created Linked List: ");
    printList(head);
    deleteLast(head, 2);
    puts("\nLinked List after Deletion of 1: ");
    printList(head);
    return 0;
}

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("\nLinked List after Deletion of 1: ");
    printList(head);
}
}
 
// This code is contributed by Arnab Kundu

Python3

# Python3 program to demonstrate deletion of
# last Node in singly linked list
 
# A linked list Node
class Node:
 
    # Constructor to initialize the node object
    def __init__(self, data):
        self.data = data
        self.next = None
 
def deleteLast(head, key) :
 
    # Initialize previous of Node to be deleted
    x = None
 
    # Start from head and find the Node to be
    # deleted
    temp = head
    while (temp != None) :
     
        # If we found the key, update xv
        if (temp.key == key) :
            x = temp
 
        temp = temp.next
     
    # key occurs at-least once
    if (x != None) :
     
        # 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
def newNode(key) :
 
    temp = Node(0)
    temp.key = key
    temp.next = None
    return temp
 
# This function prints contents of linked list
# starting from the given Node
def printList( node) :
 
    while (node != None) :
     
        print ( node.key, end = " ")
        node = node.next
     
# Driver Code
if __name__=='__main__':
 
    # Start with the empty list
    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)
 
    print("Created Linked List: ")
    printList(head)
    deleteLast(head, 2)
     
    print("\nLinked List after Deletion of 1: ")
    printList(head)
 
# This code is contributed by Arnab Kundu

C#

// C# program to demonstrate deletion of last
// Node in singly linked list
using System;
 
class GFG
{
     
 
// A linked list Node
public class Node
{
    public int key;
    public 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)
    {
        Console.Write(" {0} ", 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);
 
    Console.Write("Created Linked List: ");
    printList(head);
    deleteLast(head, 2);
    Console.Write("\nLinked List after Deletion of 1: ");
    printList(head);
}
}
 
// This code has been contributed by 29AjayKumar

Javascript

<script>
 
// A Javascript program to demonstrate
// deletion of last Node in singly
// linked list
class Node
{
    constructor(key)
    {
        this.key = key;
        this.next = null;
    }
}
 
function deleteLast(head, key)
{
     
    // Initialize previous of Node to be deleted
    let x = null;
  
    // Start from head and find the Node to be
    // deleted
    let 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;
}
 
// This function prints contents of linked
// list starting from the given Node
function printList(node)
{
    while (node != null)
    {
        document.write(node.key + " ");
        node = node.next;
    }
}
 
// Driver code
let head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(5);
head.next.next.next.next = new Node(2);
head.next.next.next.next.next = new Node(10);
 
document.write("Created Linked List: <br>");
printList(head);
deleteLast(head, 2);
 
document.write("<br>Linked List after " +
               "Deletion of 1: <br>");
printList(head);
 
// This code is contributed by rag2127
 
</script>

Output:

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

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

C++

// A C++ program to demonstrate deletion of last
// Node in singly linked list
#include <bits/stdc++.h>
using namespace std;
 
// A linked list Node
struct Node {
    int data;
    struct Node* next;
};
 
// Function to delete the last occurrence
void deleteLast(struct Node* head, int x)
{
    struct Node *temp = head, *ptr = NULL;
    while (temp) {
 
        // 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;
        free(temp);
    }
}
 
/* Utility function to create a new node with
given key */
struct 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
void display(struct Node* head)
{
    struct Node* temp = head;
    if (head == NULL) {
        cout <<"NULL\n";
        return;
    }
    while (temp != NULL) {
        cout <<" --> "<< temp->data;
        temp = temp->next;
    }
    cout <<"NULL\n";
}
 
/* Driver program to test above functions*/
int main()
{
    struct 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);
    cout <<"Created Linked list: ";
    display(head);
    deleteLast(head, 4);
    cout <<"List after deletion of 4: ";
    display(head);
    return 0;
}
 
// This code is contributed by shivanisinghss2110

C

// A C program to demonstrate deletion of last
// Node in singly linked list
#include <stdio.h>
#include <stdlib.h>
 
// A linked list Node
struct Node {
    int data;
    struct Node* next;
};
 
// Function to delete the last occurrence
void deleteLast(struct Node* head, int x)
{
    struct Node *temp = head, *ptr = NULL;
    while (temp) {
 
        // 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;
        free(temp);
    }
}
 
/* Utility function to create a new node with
given key */
struct Node* newNode(int x)
{
    struct Node* node = malloc(sizeof(struct Node*));
    node->data = x;
    node->next = NULL;
    return node;
}
 
// This function prints contents of linked list
// starting from the given Node
void display(struct Node* head)
{
    struct Node* temp = head;
    if (head == NULL) {
        printf("NULL\n");
        return;
    }
    while (temp != NULL) {
        printf("%d --> ", temp->data);
        temp = temp->next;
    }
    printf("NULL\n");
}
 
/* Driver program to test above functions*/
int main()
{
    struct 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);
    printf("Created Linked list: ");
    display(head);
    deleteLast(head, 4);
    printf("List after deletion of 4: ");
    display(head);
    return 0;
}

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\n");
        return;
    }
    while (temp != null)
    {
        System.out.printf("%d --> ", temp.data);
        temp = temp.next;
    }
    System.out.print("null\n");
}
 
/* 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 */

Python3

# A Python3 program to demonstrate deletion of last
# Node in singly linked list
 
# A linked list Node
class Node:
    def __init__(self, new_data):
        self.data = new_data
        self.next = None
 
# Function to delete the last occurrence
def deleteLast(head, x):
 
    temp = head
    ptr = None
    while (temp!=None):
 
        # If found key, update
        if (temp.data == x) :
            ptr = temp    
        temp = temp.next
     
    # If the last occurrence is the last node
    if (ptr != None and ptr.next == None):
        temp = head
        while (temp.next != ptr) :
            temp = temp.next   
        temp.next = None
     
    # If it is not the last node
    if (ptr != None and ptr.next != None):
        ptr.data = ptr.next.data
        temp = ptr.next
        ptr.next = ptr.next.next
         
    return head
     
# Utility function to create a new node with
# given key
def newNode(x):
 
    node = Node(0)
    node.data = x
    node.next = None
    return node
 
# This function prints contents of linked list
# starting from the given Node
def display( head):
 
    temp = head
    if (head == None):
        print("None\n")
        return
     
    while (temp != None):
        print( temp.data," -> ",end="")
        temp = temp.next
     
    print("None")
 
# Driver code
 
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)
print("Created Linked list: ")
display(head)
head = deleteLast(head, 4)
print("List after deletion of 4: ")
display(head)
 
# This code is contributed by Arnab Kundu

C#

// C# program to demonstrate deletion of last
// Node in singly linked list
using System;
 
class GFG
{
 
// A linked list Node
public class Node
{
    public int data;
    public 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;
    }
}
 
/* 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)
    {
        Console.Write("null\n");
        return;
    }
    while (temp != null)
    {
        Console.Write("{0} --> ", temp.data);
        temp = temp.next;
    }
    Console.Write("null\n");
}
 
/* 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);
    Console.Write("Created Linked list: ");
    display(head);
    deleteLast(head, 4);
    Console.Write("List after deletion of 4: ");
    display(head);
}
}
 
// This code contributed by Rajput-Ji

Javascript

<script>
 
// JavaScript program to demonstrate
// deletion of last
// Node in singly linked list    
 
// A linked list Node
class Node {
    constructor() {
        this.data = 0;
        this.next = null;
    }
}
 
    // Function to delete the last occurrence
    function deleteLast(head , x) {
       var 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;
         
        }
    }
 
    /*
     Utility function to create a new
     node with given key
     */
    function newNode(x) {
       var node = new Node();
        node.data = x;
        node.next = null;
        return node;
    }
 
    // This function prints contents of linked list
    // starting from the given Node
    function display(head) {
        var temp = head;
        if (head == null) {
            document.write("null<br/>");
            return;
        }
        while (temp != null) {
            document.write( temp.data + " --> ");
            temp = temp.next;
        }
        document.write("null<br/>");
    }
 
    /* Driver code */
     
        var 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);
        document.write("Created Linked list: ");
        display(head);
        deleteLast(head, 4);
        document.write("List after deletion of 4: ");
        display(head);
 
// This code contributed by gauravrajput1
 
</script>

Output:

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

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes