Delete from Beginning of Doubly Linked List in DSA C - Build from Scratch

Delete from Beginning of Doubly Linked List

📖 Scenario: You are managing a playlist of songs using a doubly linked list. Each song is a node with a title and links to the previous and next songs. You want to remove the first song from the playlist.

🎯 Goal: Build a program that creates a doubly linked list with three songs, then deletes the first song from the list, and finally prints the updated playlist.

📋 What You'll Learn

Create a doubly linked list with exactly three nodes containing the song titles: "Song1", "Song2", and "Song3"

Create a pointer variable called head that points to the first node

Write a function called deleteFromBeginning that deletes the first node of the doubly linked list

Print the updated list from the head to the end after deletion

💡 Why This Matters

🌍 Real World

Doubly linked lists are used in music players, browsers, and other apps to move forward and backward through items efficiently.

💼 Career

Understanding linked list operations is fundamental for software developers working with dynamic data structures and memory management.

1

Create the doubly linked list with three songs

Create a struct called Node with members char title[20], struct Node *prev, and struct Node *next. Then create three nodes with titles "Song1", "Song2", and "Song3". Link them to form a doubly linked list. Create a pointer called head that points to the first node.

DSA C

// Define struct Node and create three linked nodes with titles
// Link nodes to form doubly linked list
// Create pointer head pointing to first node

Hint

Use malloc to create nodes and strcpy to set titles. Link nodes by setting prev and next pointers.

2

Create a function to delete the first node

Create a function called deleteFromBeginning that takes a pointer to Node * called head and deletes the first node of the doubly linked list. Update head to point to the new first node. Handle the case when the list is empty or has only one node.

DSA C

#include 
#include 
#include 

typedef struct Node {
    char title[20];
    struct Node *prev;
    struct Node *next;
} Node;

// Write function deleteFromBeginning here

int main() {
    Node *head = (Node *)malloc(sizeof(Node));
    Node *second = (Node *)malloc(sizeof(Node));
    Node *third = (Node *)malloc(sizeof(Node));

    strcpy(head->title, "Song1");
    head->prev = NULL;
    head->next = second;

    strcpy(second->title, "Song2");
    second->prev = head;
    second->next = third;

    strcpy(third->title, "Song3");
    third->prev = second;
    third->next = NULL;

    // Your code here
}

Hint

Use a double pointer Node **head to modify the head pointer inside the function. Free the old first node after updating the head.

3

Call the delete function to remove the first song

In the main function, call the deleteFromBeginning function with the address of head to delete the first node from the doubly linked list.

DSA C

#include 
#include 
#include 

typedef struct Node {
    char title[20];
    struct Node *prev;
    struct Node *next;
} Node;

void deleteFromBeginning(Node **head) {
    if (*head == NULL) {
        return;
    }
    Node *temp = *head;
    *head = (*head)->next;
    if (*head != NULL) {
        (*head)->prev = NULL;
    }
    free(temp);
}

int main() {
    Node *head = (Node *)malloc(sizeof(Node));
    Node *second = (Node *)malloc(sizeof(Node));
    Node *third = (Node *)malloc(sizeof(Node));

    strcpy(head->title, "Song1");
    head->prev = NULL;
    head->next = second;

    strcpy(second->title, "Song2");
    second->prev = head;
    second->next = third;

    strcpy(third->title, "Song3");
    third->prev = second;
    third->next = NULL;

    // Call deleteFromBeginning here
    // Your code here

    return 0;
}

Hint

Call the function with &head to pass the address of the head pointer.

4

Print the updated doubly linked list

Write a while loop in main to print the titles of the songs in the updated doubly linked list starting from head. Print each title followed by " -> ". After the last node, print "NULL".

DSA C

#include 
#include 
#include 

typedef struct Node {
    char title[20];
    struct Node *prev;
    struct Node *next;
} Node;

void deleteFromBeginning(Node **head) {
    if (*head == NULL) {
        return;
    }
    Node *temp = *head;
    *head = (*head)->next;
    if (*head != NULL) {
        (*head)->prev = NULL;
    }
    free(temp);
}

int main() {
    Node *head = (Node *)malloc(sizeof(Node));
    Node *second = (Node *)malloc(sizeof(Node));
    Node *third = (Node *)malloc(sizeof(Node));

    strcpy(head->title, "Song1");
    head->prev = NULL;
    head->next = second;

    strcpy(second->title, "Song2");
    second->prev = head;
    second->next = third;

    strcpy(third->title, "Song3");
    third->prev = second;
    third->next = NULL;

    deleteFromBeginning(&head);

    // Print the updated list
    // Your code here

    return 0;
}

Hint

Use a while loop to traverse from head to the end, printing each title followed by " -> ". After the loop, print "NULL".

Practice

1. What happens to the head pointer when you delete the first node from a doubly linked list?

easy

A. It remains unchanged

B. It becomes NULL immediately

C. It moves to the second node in the list

D. It points to the last node

Solution

1. Step 1: Understand the head pointer role

   The head pointer points to the first node in the doubly linked list.

2. Step 2: Effect of deleting the first node

   When the first node is deleted, the head pointer must move to the next node, which becomes the new first node.

3. Final Answer:

   It moves to the second node in the list -> Option C

4. Quick Check:

   Head points to new first node after deletion [OK]

Hint: Head always moves to next node after deleting first [OK]

Common Mistakes:

• Assuming head becomes NULL even if list has more nodes
• Not updating head pointer after deletion
• Pointing head to last node mistakenly

2. Which of the following is the correct syntax to delete the first node in a doubly linked list in C?

easy

A. temp = head; head = head->next; free(temp); head->prev = NULL;

B. free(head); head = head->next; head->prev = NULL;

C. head = head->next; free(head->prev); head->prev = NULL;

D. head->prev = NULL; free(head); head = head->next;

Solution

1. Step 1: Store current head in temp

   We save the current first node in a temporary pointer to free it later.

2. Step 2: Move head to next node and free old head

   Update head to point to the second node, free the old first node, and set new head's prev to NULL.

3. Final Answer:

   temp = head; head = head->next; free(temp); head->prev = NULL; -> Option A

4. Quick Check:

   Proper order: save, move, free, update pointers [OK]

Hint: Save old head before freeing, then update pointers [OK]

Common Mistakes:

• Freeing head before moving pointer
• Not setting new head's prev to NULL
• Accessing freed memory after free

3. Given the doubly linked list: 10 <-> 20 <-> 30 <-> NULL, what will be the list after deleting the first node?

medium

A. 20 <-> 30 <-> NULL

B. 10 <-> 30 <-> NULL

C. 30 <-> NULL

D. NULL

Solution

1. Step 1: Identify the first node to delete

   The first node has value 10, which will be removed.

2. Step 2: Update head to second node and adjust pointers

   Head moves to node with value 20, and its prev pointer is set to NULL.

3. Final Answer:

   20 <-> 30 <-> NULL -> Option A

4. Quick Check:

   First node removed, list starts at 20 [OK]

Hint: After deletion, list starts from second node [OK]

Common Mistakes:

• Leaving old head in list
• Not updating prev pointer of new head
• Deleting wrong node

4. What is wrong with this code snippet for deleting the first node of a doubly linked list?

void deleteBegin() {
  if (head == NULL) return;
  free(head);
  head = head->next;
  if (head != NULL) head->prev = NULL;
}

medium

A. It does not free the node

B. It does not check if list is empty

C. It forgets to set head->prev to NULL

D. It frees head before moving pointer, causing invalid access

Solution

1. Step 1: Analyze order of operations

   The code frees head first, then tries to access head->next, which is invalid after free.

2. Step 2: Correct order needed

   We must first save head->next in a temp pointer, move head, then free old node to avoid invalid memory access.

3. Final Answer:

   It frees head before moving pointer, causing invalid access -> Option D

4. Quick Check:

   Free after pointer update to avoid invalid access [OK]

Hint: Always move pointer before freeing old node [OK]

Common Mistakes:

• Freeing node before updating pointers
• Accessing freed memory
• Not handling empty list properly

5. You have a doubly linked list with nodes: 5 <-> 15 <-> 25 <-> 35 <-> NULL. After deleting the first node twice, what will be the list?

hard

A. 15 <-> 25 <-> 35 <-> NULL

B. 25 <-> 35 <-> NULL

C. 35 <-> NULL

D. NULL

Solution

1. Step 1: Delete first node once

   First deletion removes node with value 5, head moves to 15.

2. Step 2: Delete first node again

   Second deletion removes node with value 15, head moves to 25.

3. Final Answer:

   25 <-> 35 <-> NULL -> Option B

4. Quick Check:

   Two deletions remove first two nodes [OK]

Hint: Each deletion moves head to next node [OK]

Common Mistakes:

• Deleting only once instead of twice
• Not updating head correctly after second deletion
• Confusing node values after deletion