Delete from Beginning of Doubly Linked List in DSA C

Mental Model

To remove the first item, we move the start pointer to the next item and fix links so the list stays connected.

Analogy: Imagine a train where you remove the first carriage and connect the engine directly to the second carriage.

null ← 1 ↔ 2 ↔ 3 ↔ 4 -> null
↑start

Dry Run Walkthrough

Input: list: 1 ↔ 2 ↔ 3 ↔ 4, delete from beginning

Goal: Remove the first node and update the list to start from the second node

Step 1: store pointer to first node (1) to delete

null ← [1] ↔ 2 ↔ 3 ↔ 4 -> null
↑start

Why: We need to remember the node to free it later

Step 2: move start pointer to second node (2)

null ← 1 ↔ [2] ↔ 3 ↔ 4 -> null
↑start

Why: The list should now start from the second node

Step 3: set previous pointer of new start (2) to null

null ← [2] ↔ 3 ↔ 4 -> null
↑start

Why: First node has no previous node

Step 4: free the old first node (1)

null ← 2 ↔ 3 ↔ 4 -> null
↑start

Why: Remove the old node from memory

Result:

null ← 2 ↔ 3 ↔ 4 -> null
↑start

Annotated Code

DSA C

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

// Node structure for doubly linked list
typedef struct Node {
    int data;
    struct Node* prev;
    struct Node* next;
} Node;

// Function to delete from beginning
void deleteFromBeginning(Node** start) {
    if (*start == NULL) return; // empty list check

    Node* toDelete = *start; // remember first node
    *start = toDelete->next; // move start to second node

    if (*start != NULL) {
        (*start)->prev = NULL; // new start has no previous
    }

    free(toDelete); // free old first node
}

// Helper to print list
void printList(Node* start) {
    Node* curr = start;
    while (curr != NULL) {
        printf("%d", curr->data);
        if (curr->next != NULL) printf(" ↔ ");
        curr = curr->next;
    }
    printf(" -> null\n");
}

// Helper to create new node
Node* newNode(int data) {
    Node* node = (Node*)malloc(sizeof(Node));
    node->data = data;
    node->prev = NULL;
    node->next = NULL;
    return node;
}

int main() {
    // Create list 1 ↔ 2 ↔ 3 ↔ 4
    Node* start = newNode(1);
    Node* second = newNode(2);
    Node* third = newNode(3);
    Node* fourth = newNode(4);

    start->next = second;
    second->prev = start;
    second->next = third;
    third->prev = second;
    third->next = fourth;
    fourth->prev = third;

    printf("Original list:\n");
    printList(start);

    deleteFromBeginning(&start);

    printf("After deleting from beginning:\n");
    printList(start);

    return 0;
}

if (*start == NULL) return; // empty list check

check if list is empty to avoid errors

Node* toDelete = *start; // remember first node

store pointer to first node to delete later

*start = toDelete->next; // move start to second node

advance start pointer to second node

if (*start != NULL) { (*start)->prev = NULL; }

set new start's prev pointer to null

free(toDelete); // free old first node

release memory of removed node

Output

Original list:

1 ↔ 2 ↔ 3 ↔ 4 -> null

After deleting from beginning:

2 ↔ 3 ↔ 4 -> null

Complexity Analysis

Time: O(1) because we only change a few pointers without traversing the list

Space: O(1) because no extra space is used besides a few pointers

vs Alternative: Compared to deleting from the end which may require traversal, deleting from beginning is faster and simpler

Edge Cases

empty list

function returns immediately without changes

DSA C

if (*start == NULL) return; // empty list check

list with one node

start becomes NULL after deletion, list becomes empty

DSA C

*start = toDelete->next; // move start to second node

When to Use This Pattern

When you need to remove the first item quickly from a doubly linked list, use this pattern to update pointers safely and efficiently.

Common Mistakes

Mistake: Not setting the new start node's prev pointer to NULL after deletion
Fix: Always set (*start)->prev = NULL if the new start is not NULL

Mistake: Not checking if the list is empty before deleting
Fix: Add a check if (*start == NULL) before proceeding

Summary

Deletes the first node of a doubly linked list by moving the start pointer and fixing links.

Use when you want to remove the front element quickly from a doubly linked list.

The key is to update the start pointer and set the new first node's previous pointer to 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