# Delete first node in linked list: Program and Algorithm

In this article, you’ll learn how to delete first node in linked list in C++, along with that you’ll also see the algorithm to delete first node in linked list.

So, Let’s get started!

Prerequisite: You should have the knowledge of How do you create a node in a linked list? and How to traverse a singly linked list?

## How do you delete first node in linked list?

Let’s see how you can delete first node in linked list step-by-step:

Variables we are using here:

1. head : A pointer of `Node` type pointing to the first node of the linked list.
2. temp: A pointer of `Node` type which is also pointing to the first node (i.e., head).

The following algorithm deletes first node in linked list:

• Step 01: Start
• Step 02: If `head == NULL`
• Step 03: Return `NULL`
• Step 04: Go to step `11`
• Step 05: [End of If ]
• Step 06: Create a new node named `temp` of `Node` type and initialize it with head.
• Step 07: Set `head = head -> next`
• Step 08: Set `temp -> next = NULL`
• Step 09: Delete `temp`
• Step 10: Return `head`
• Step 11: Stop

### Visual Representation:

Explanation of the above algorithm:

So, If you see the line number `78` of the below code, you’ll find, we are defining a function named as `deleteFirstNode`.

And, in that function (i.e., `deleteFirstNode` function), we are passing the `head` pointer of the linked list as a parameter whose first node we wish to delete.

The return type of this `deleteFirstNode` function is a pointer of `Node` type.

Yup! I know, I know…

You might be wondering, why the return type of this `deleteFirstNode` function is a pointer of `Node` type here. Right?

It’s only because, after deleting the first node of this linked list we will return the head of that list which will now point to the second node of the same linked list. As the first node will have been deleted.

Now, inside the function, we are checking a condition, whether the linked list is empty or not.

So, if the linked list is empty which means, the head pointer is pointing to `NULL` (i.e., `head == NULL`), we don’t need to delete anything. Right?

Because, if the list is already empty then what is left to delete. ?

After that, in the next statement we are creating a pointer of node type named `temp` which is pointing to the first node of the linked list.

Now, your question would be, Why we are creating this pointer? Right?

We are creating this temp pointer because, as you already know, we have to delete the first node of this list.

So, to access or to keep track of this first node we must assign the address of this first node to some variable. which will help to delete this node.

Because, if you’ll not delete the first node, it will be somewhere in the memory without any use.

So, it is better to delete this node or free the memory acquired by it.

Now, we have to move our head pointer towards right so that it can point to the second node of the list.

Why this step is required ?

Because, here we can see that the first node has to be deleted. and, if head is still pointing to the first node then it does not make any sense. Right?

Here, the head pointer must point to the second node of the list, because, after deleting the first node the second node becomes the first node of the updated list.

And, that’s why, `head` must always point to the second node after deleting the first node.

After that, before deleting the `temp` which is a pointer to the first node, we have to make sure that the `temp` must point to `NULL`.

Because, now it will not point to any node.

So, it is better to point to `NULL` to avoid any type of `error`.

And, at last we are releasing or free the memory allocated to the `temp` pointer with the help of destructor (which we have defined at the beginning of the code).

Simply by writing the `delete` keyword followed by the name of the pointer which we wish to delete.

And, then we are returning the `head` pointer of new updated linked list.

That’s it…

Now, we are ready to go.

So, let’s dive into the actual coding part…

## Implementation in C++:

```// writing a program in C++ to delete first node of a linked list

#include<iostream>
using namespace std;

// creating a class "Node"
class Node
{
public:
int data;
Node *next;

//constructor
Node(int data)
{
this -> data = data;
this -> next = NULL;
}

//destructor
~Node()
{
if(this -> next != NULL)
{
delete next;
this -> next = NULL;
}
}
};

{
cout << "List is empty" << endl;
else
{

while(temp != NULL)
{
cout << temp -> data << " -> " ;
temp = temp -> next;
}
cout << "Null" << endl;
}
}

// function to insert a node at the tail of a linked list

{
//creation of a new node
Node* tail = new Node(data);

//empty list

else
{

while(temp -> next != NULL)
{
temp = temp -> next;
}
temp -> next = tail;
}

}

// function to delete first node of a linked list

{
return NULL;

temp -> next = NULL;
delete temp;

}

//Driver's code

int main()
{
// if list is not empty

Node* node1 = new Node(3);

return 0;

}

```

If you compile and run the above program, it will produce the following result:

Output:

```// before deletion of the first node (when we didn't call the deleteFirstNode() function)

3 -> 11 -> 27 -> 99 -> Null

// after deletion of the first node (when we call the deleteFirstNode() function)

11 -> 27 -> 99 -> Null

```

## Conclusion:

In this article, you learned how to delete first node of a linked list in C++, you also became familiar with the algorithm to delete the first node of a linked list.

So,

I really hope that you liked my article and got your answer.