Deletion at end (Removal of last node) in a Linked List

Last Updated : 30 Jul, 2024

Given a linked list, the task is to delete the last node of the given linked list.

Examples:

Input: 1 -> 2 -> 3 -> 4 -> 5 -> NULL
Output: 1 -> 2 -> 3 -> 4 -> NULL
Explanation: The last node of the linked list is 5, so 5 is deleted.
Input: 3 -> 12 -> 15-> NULL
Output: 3 -> 12 -> NULL
Explanation: The last node of the linked list is 15, so 15 is deleted.

Approach:

To perform the deletion operation at the end of linked list, we need to traverse the list to find the second last node, then set its next pointer to null. If the list is empty then there is no node to delete or has only one node then point head to null.

Deletion-At-End — Deletion at the end of linked list

Step-by-step approach:

Check if list is empty then return NULL.
If the list has only one node then delete it and return NULL.
Traverse the list to find the second last node.
- Set the next pointer of second last node to NULL.

Implementation:

C++

// C++ program to delete the last node of linked list
#include <iostream>
using namespace std;

// Node structure for the linked list
struct Node {
    int data;
    Node* next;
    Node(int data)
        : data(data)
        , next(nullptr)
    {
    }
};

// Function to remove the last node
// of the linked list
Node* removeLastNode(struct Node* head)
{
    // If the list is empty, return nullptr
    if (head == nullptr) {
        return nullptr;
    }

    // If the list has only one node, delete it and return
    // nullptr
    if (head->next == nullptr) {
        delete head;
        return nullptr;
    }

    // Find the second last node
    Node* second_last = head;
    while (second_last->next->next != nullptr) {
        second_last = second_last->next;
    }

    // Delete the last node
    delete (second_last->next);

    // Change next of second last
    second_last->next = nullptr;

    return head;
}

void printList(Node* head)
{
    while (head != nullptr) {
        cout << head->data << " -> ";
        head = head->next;
    }
    cout << "nullptr" << endl;
}

// Driver code
int main()
{
    // Creating a static linked list
    // 1 -> 2 -> 3 -> 4 -> 5 -> nullptr
    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);

    cout << "Original list: ";
    printList(head);

    // Removing the last node
    head = removeLastNode(head);

    cout << "List after removing the last node: ";
    printList(head);


    return 0;
}

// C program to delete the last node of linked list

#include <stdio.h>
#include <stdlib.h>

// Node structure for the linked list
struct Node {
    int data;
    struct Node* next;
};

// Function to create a new node
struct Node* createNode(int data)
{
    struct Node* newNode
        = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// Function to remove the last node of the linked list
struct Node* removeLastNode(struct Node* head)
{
    // If the list is empty, return NULL
    if (head == NULL) {
        return NULL;
    }

    // If the list has only one node, delete it and return
    // NULL
    if (head->next == NULL) {
        free(head);
        return NULL;
    }

    // Find the second last node
    struct Node* second_last = head;
    while (second_last->next->next != NULL) {
        second_last = second_last->next;
    }

    // Delete the last node
    free(second_last->next);

    // Change next of second last
    second_last->next = NULL;

    return head;
}

// Function to print linked list
void printList(struct Node* head)
{
    while (head != NULL) {
        printf("%d -> ", head->data);
        head = head->next;
    }
    printf("NULL\n");
}

// Driver code
int main()
{
    // Creating a static linked list
    // 1 -> 2 -> 3 -> 4 -> 5 -> NULL
    struct Node* head = createNode(1);
    head->next = createNode(2);
    head->next->next = createNode(3);
    head->next->next->next = createNode(4);
    head->next->next->next->next = createNode(5);

    printf("Original list: ");
    printList(head);

    // Removing the last node
    head = removeLastNode(head);

    printf("List after removing the last node: ");
    printList(head);

    return 0;
}

Java

// C program to delete the last node of linked list

// Node structure for the linked list
class Node {
    int data;
    Node next;

    Node(int data)
    {
        this.data = data;
        this.next = null;
    }
}

public class GFG {

    // Function to remove the last node of the linked list
    public static Node removeLastNode(Node head)
    {

        // If the list is empty, return null
        if (head == null) {
            return null;
        }

        // If the list has only one node, delete it and
        // return null
        if (head.next == null) {
            return null;
        }

        // Find the second last node
        Node secondLast = head;
        while (secondLast.next.next != null) {
            secondLast = secondLast.next;
        }

        // Delete the last node
        secondLast.next = null;

        return head;
    }

    // Function to print the linked list
    public static void printList(Node head)
    {
        while (head != null) {
            System.out.print(head.data + " -> ");
            head = head.next;
        }
        System.out.println("null");
    }

    // Driver code
    public static void main(String[] args)
    {

        // Creating a static linked list
        // 1 -> 2 -> 3 -> 4 -> 5 -> null
        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);

        System.out.println("Original list: ");
        printList(head);

        // Removing the last node
        head = removeLastNode(head);

        System.out.println(
            "List after removing the last node: ");
        printList(head);
    }
}

Python

# Python program to delete the last node of linked list

# Node structure for the linked list
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

# Function to remove the last node of the linked list
def remove_last_node(head):
    # If the list is empty, return None
    if not head:
        return None

    # If the list has only one node, delete it and return None
    if not head.next:
        return None

    # Find the second last node
    second_last = head
    while second_last.next.next:
        second_last = second_last.next

    # Delete the last node
    second_last.next = None

    return head

# Function to print the linked list
def print_list(head):
    while head:
        print(head.data, end=" -> ")
        head = head.next
    print("None")


# Driver code
if __name__ == "__main__":

    # Creating a static linked list
    # 1 -> 2 -> 3 -> 4 -> 5 -> None
    head = Node(1)
    head.next = Node(2)
    head.next.next = Node(3)
    head.next.next.next = Node(4)
    head.next.next.next.next = Node(5)

    print("Original list: ")
    print_list(head)

    # Removing the last node
    head = remove_last_node(head)

    print("List after removing the last node: ")
    print_list(head)

// C# program to delete the last node of linked list

using System;

// Node structure for the linked list
public class Node {
    public int data;
    public Node next;

    public Node(int data)
    {
        this.data = data;
        this.next = null;
    }
}

public class LinkedList {

    // Function to remove the last node of the linked list
    public static Node RemoveLastNode(Node head)
    {
        // If the list is empty, return null
        if (head == null) {
            return null;
        }

        // If the list has only one node, delete it and
        // return null
        if (head.next == null) {
            return null;
        }

        // Find the second last node
        Node secondLast = head;
        while (secondLast.next.next != null) {
            secondLast = secondLast.next;
        }

        // Delete the last node
        secondLast.next = null;

        return head;
    }

    // Function to print the linked list
    public static void PrintList(Node head)
    {
        while (head != null) {
            Console.Write(head.data + " -> ");
            head = head.next;
        }
        Console.WriteLine("null");
    }

    // Driver code
    public static void Main(string[] args)
    {
        // Creating a static linked list
        // 1 -> 2 -> 3 -> 4 -> 5 -> null
        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);

        Console.WriteLine("Original list: ");
        PrintList(head);

        // Removing the last node
        head = RemoveLastNode(head);

        Console.WriteLine(
            "List after removing the last node: ");
        PrintList(head);
    }
}

JavaScript

// Javascript program to delete the last node of linked list

// Node structure for the linked list
class Node {
    constructor(data) {
        this.data = data;
        this.next = null;
    }
}

// Function to remove the last node of the linked list
function removeLastNode(head) {
    // If the list is empty, return null
    if (!head) {
        return null;
    }

    // If the list has only one node, delete it and return null
    if (!head.next) {
        return null;
    }

    // Find the second last node
    let secondLast = head;
    while (secondLast.next.next) {
        secondLast = secondLast.next;
    }

    // Delete the last node
    secondLast.next = null;

    return head;
}

// Function to print the linked list
function printList(head) {
    while (head) {
        process.stdout.write(head.data + " -> ");
        head = head.next;
    }
    console.log("null");
}

// Driver code
// Creating a static linked list
// 1 -> 2 -> 3 -> 4 -> 5 -> null
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);

console.log("Original list: ");
printList(head);

// Removing the last node
head = removeLastNode(head);

console.log("List after removing the last node: ");
printList(head);

Output

Original list: 1 -> 2 -> 3 -> 4 -> 5 -> nullptr
List after removing the last node: 1 -> 2 -> 3 -> 4 -> nullptr

Time Complexity: O(n), traversal of the linked list till its end, so the time complexity required is O(n).
Auxiliary Space: O(1)

Deletion at beginning (Removal of first node) in a Doubly Linked List

VishalBachchas

Improve

Article Tags :

Practice Tags :

Deletion at end (Removal of last node) in a Linked List

Similar Reads

Thank You!

What kind of Experience do you want to share?