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

Last Updated : 21 Oct, 2025

Given a head of the linked list, we need to remove the first node from the given linked list.

Examples:

Input :

blobid2_1755951985

Output : 2 -> 3 -> 1 -> 7 -> NULL
Explanation: After deleting head from the given linked list, we'll be left with just 2 -> 3 -> 1 -> 7.

blobid3_1755951992


Input :

blobid0_1755949645

Output : 5 -> 7 -> 8 -> 99 -> 100 -> NULL
Explanation: After deleting head from the given linked list, we'll be left with just 5 -> 7 -> 8 -> 99 -> 100.

blobid1_1755949657
Try It Yourself
redirect icon

By Shifting head node to next node of head - O(1) Time and O(1) Space

To remove the first node of a linked list, store the current head in a temporary variable (temp), move the head pointer to the next node, delete the temporary head node and finally , return the new head of the linked list.


Below is the implementation of the above approach:

C++ 
#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node *next;
    Node(int x) {
        data = x;
        next = nullptr;
    }
};

// Delete the head node and return the new head
Node* deleteHead(Node* head) {
  
    // Check if the list is empty
    if (head == nullptr)
        return nullptr;

    // Store the current head in a
    // temporary variable
    Node* temp = head;

    // Move the head pointer to the next node
    head = head->next;

    // Free the memory of the old head node
    delete temp;

    return head;
}

// Function to print the linked list
void printList(Node* curr) {
    while (curr != nullptr) {
        cout << curr->data;
        if (curr->next != nullptr) {
            cout << " -> ";
        }
        curr = curr->next; 
    }
}

int main() {
  
    // Create a hard-coded linked list:
    // 8 -> 2 -> 3 -> 1 -> 7
    Node* head = new Node(8);
    head->next = new Node(2);
    head->next->next = new Node(3);
    head->next->next->next = new Node(1);
    head->next->next->next->next = new Node(7);

    head = deleteHead(head); 
    printList(head);

    return 0;
}
C 
#include <stdio.h>
#include <stdlib.h>

// Define a linked list node
struct Node
{
    int data;
    struct Node *next;
};

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

// Delete the head node and return the new head
struct Node *deleteHead(struct Node *head)
{
    if (head == NULL)
        return NULL;

    struct Node *temp = head;
    head = head->next;
    free(temp); // Free memory of old head

    return head;
}

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

int main()
{
    // Create a hard-coded linked list: 8 -> 2 -> 3 -> 1 -> 7
    struct Node *head = createNode(8);
    head->next = createNode(2);
    head->next->next = createNode(3);
    head->next->next->next = createNode(1);
    head->next->next->next->next = createNode(7);

    // Delete the head node
    head = deleteHead(head);

    // Print the updated list
    printList(head);

    return 0;
}
Java 
class Node {
    int data;
    Node next;

    Node(int x) {
        data = x;
        next = null;
    }
}

class GfG {

    // Delete the head node and return the new head
    static Node deleteHead(Node head) {

        // Check if the list is empty
        if (head == null)
            return null;

        // Store the current head in a
        // temporary variable
        Node temp = head;

        // Move the head pointer to the next node
        head = head.next;

        // Free the memory of the old head node
        temp = null;

        return head;
    }

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

    public static void main(String[] args) {

        // Create a hard-coded linked list:
        // 8 -> 2 -> 3 -> 1 -> 7
        Node head = new Node(8);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(1);
        head.next.next.next.next = new Node(7);

        head = deleteHead(head); 
        printList(head);
    }
}
Python 
class Node:
    def __init__(self, x):
        self.data = x
        self.next = None


# Delete the head node and return the new head
def deleteHead(head):

    # Check if the list is empty
    if head is None:
        return None

    # Store the current head in a
    # temporary variable
    temp = head

    # Move the head pointer to the next node
    head = head.next

    # Free the memory of the old head node
    # (Python garbage collector will handle it)
    temp = None

    return head


# Function to print the linked list
def printList(curr):
    while curr is not None:
        print(curr.data, end="")
        if curr.next is not None:
            print(" -> ", end="")
        curr = curr.next


if __name__ == "__main__":

    # Create a hard-coded linked list:
    # 8 -> 2 -> 3 -> 1 -> 7
    head = Node(8)
    head.next = Node(2)
    head.next.next = Node(3)
    head.next.next.next = Node(1)
    head.next.next.next.next = Node(7)

    head = deleteHead(head)  
    printList(head)
C# 
using System;

class Node {
    public int data;
    public Node next;

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

class GfG {

    // Delete the head node and return the new head
    public static Node DeleteHead(Node head) {

        // Check if the list is empty
        if (head == null)
            return null;

        // Move the head pointer to the next node
        Node temp = head;
        head = head.next;

        // Free the memory of the old head node
        temp = null;

        return head;
    }

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

    public static void Main(string[] args) {

        // Create a hard-coded linked list:
        // 8 -> 2 -> 3 -> 1 -> 7
        Node head = new Node(8);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(1);
        head.next.next.next.next = new Node(7);

        head = DeleteHead(head);
        PrintList(head);
    }
}
JavaScript 
class Node {
    constructor(x) {
        this.data = x;
        this.next = null;
    }
}

class GfG {

    // Delete the head node and return the new head
    static deleteHead(head) {

        // Check if the list is empty
        if (head === null)
            return null;

        // Move the head pointer to the next node
        let temp = head;
        head = head.next;

        // Free the memory of the old head node (not needed in JS, GC handles it)
        temp = null;

        return head;
    }

    // Function to print the linked list
    static printList(curr) {
        while (curr !== null) {
            process.stdout.write(curr.data.toString());
            if (curr.next !== null) {
                process.stdout.write(" -> ");
            }
            curr = curr.next;
        }
        console.log();
    }
}

// Driver code
// Create a hard-coded linked list:
// 8 -> 2 -> 3 -> 1 -> 7
let head = new Node(8);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(1);
head.next.next.next.next = new Node(7);

head = GfG.deleteHead(head);
GfG.printList(head);

Output
2 -> 3 -> 1 -> 7

Time Complexity: O(1), because the operation to delete the head node is performed in constant time.
Space Complexity: O(1)

Comment

Explore