Why Doubly Linked List Over Singly Linked List in DSA C - Why It Works

Concept Flow - Why Doubly Linked List Over Singly Linked List

Start with Singly Linked List

↓

Can only move forward

↓

Operations like reverse or delete require traversal from head

↓

Add 'prev' pointer to each node

↓

Now Doubly Linked List

↓

Can move forward and backward

↓

Operations like reverse, delete, insert easier and faster

↓

More memory used but more flexible

Shows how adding a backward pointer to singly linked list nodes creates a doubly linked list that supports two-way traversal and easier operations.

Execution Sample

DSA C

struct Node {
  int data;
  struct Node* next;
  struct Node* prev; // only in doubly linked list
};

Defines a node structure showing the extra 'prev' pointer in doubly linked list nodes.

Execution Table

Step	Operation	Nodes in List	Pointer Changes	Visual State
1	Create singly linked list with nodes 1->2->3	1->2->3	head points to 1, next links forward	1 -> 2 -> 3 -> null
2	Try to move backward from node 3	1->2->3	No prev pointer, cannot move backward	1 -> 2 -> 3 -> null (no backward link)
3	Create doubly linked list with nodes 1<->2<->3	1<->2<->3	head points to 1, next and prev links set	null <- 1 <-> 2 <-> 3 -> null
4	Move backward from node 3 to node 2	1<->2<->3	prev pointer from 3 points to 2	null <- 1 <-> 2 <-> 3 -> null
5	Delete node 2 in singly linked list	1->2->3	Must traverse from head to find node before 2	1 -> 3 -> null (after deletion)
6	Delete node 2 in doubly linked list	1<->2<->3	Use prev pointer from 3 to update links directly	null <- 1 <-> 3 -> null (after deletion)
7	End	Final states shown	Operations easier in doubly linked list	Singly: 1 -> 3 -> null, Doubly: null <- 1 <-> 3 -> null

💡 Operations like backward traversal and deletion are simpler in doubly linked list due to prev pointers.

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 4	After Step 6	Final
head	null	points to node 1 (singly)	points to node 1 (doubly)	points to node 1 (doubly)	points to node 1 (doubly)	points to node 1 (doubly)
node1.next	null	points to node 2	points to node 2	points to node 2	points to node 3	points to node 3
node1.prev	null	null (singly)	null (doubly)	null (doubly)	null (doubly)	null (doubly)
node2.next	null	points to node 3	points to node 3	points to node 3	null (deleted)	null
node2.prev	null	null (singly)	points to node 1 (doubly)	points to node 1 (doubly)	null (deleted)	null
node3.next	null	null	null	null	null	null
node3.prev	null	null	points to node 2 (doubly)	points to node 2 (doubly)	points to node 1 (doubly)	points to node 1 (doubly)

Key Moments - 3 Insights

Why can't we move backward in a singly linked list?

Because singly linked list nodes only have 'next' pointers, no 'prev' pointers to go backward, as shown in execution_table step 2.

How does having a 'prev' pointer make deletion easier?

With 'prev' pointer, we can directly access the previous node to update its 'next' pointer during deletion, avoiding full traversal, as shown in steps 5 and 6.

Does doubly linked list use more memory?

Yes, each node stores an extra 'prev' pointer, increasing memory usage but enabling easier two-way traversal and operations.

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what happens when trying to move backward from node 3 in singly linked list?

A We cannot move backward because there is no prev pointer

B We can move backward using the prev pointer

C We move forward instead

D The list is reversed automatically

💡 Hint

Check execution_table row for step 2 under 'Pointer Changes' and 'Visual State'

At which step in execution_table is the doubly linked list created?

A Step 1

B Step 2

C Step 3

D Step 5

💡 Hint

Look for the step where nodes have both next and prev pointers set

If we remove the 'prev' pointer from doubly linked list nodes, how would deletion change as shown in execution_table?

A Deletion would be easier and faster

B Deletion would require traversal from head to find previous node

C Deletion would not be possible

D Deletion would happen automatically

💡 Hint

Compare steps 5 and 6 in execution_table about deletion process

Concept Snapshot

Singly linked list nodes have only 'next' pointer.
Doubly linked list nodes have 'next' and 'prev' pointers.
Prev pointer allows backward traversal.
Operations like reverse and delete are easier.
Doubly linked list uses more memory but is more flexible.

Full Transcript

This visual execution compares singly and doubly linked lists. Singly linked lists have nodes with only a 'next' pointer, allowing only forward movement. Doubly linked lists add a 'prev' pointer to each node, enabling backward movement. This extra pointer makes operations like reverse traversal and node deletion easier and faster because we can directly access previous nodes without starting from the head. However, doubly linked lists use more memory due to the extra pointer. The execution table shows step-by-step how nodes link and how operations differ. Variable tracking shows pointer changes. Key moments clarify common confusions about traversal and deletion. The quiz tests understanding of these differences.

Practice

1. Why might a doubly linked list be preferred over a singly linked list?

easy

A. Because it cannot be modified after creation

B. Because it uses less memory than singly linked list

C. Because it only stores one pointer per node

D. Because it allows traversal in both forward and backward directions

Solution

1. Step 1: Understand traversal capabilities

   A singly linked list allows traversal only in one direction, from head to tail.

2. Step 2: Compare with doubly linked list

   A doubly linked list stores two pointers per node, allowing traversal forward and backward.

3. Final Answer:

   Because it allows traversal in both forward and backward directions -> Option D

4. Quick Check:

   Traversal direction = Both [OK]

Hint: Doubly linked lists have two pointers per node [OK]

Common Mistakes:

• Thinking doubly linked lists use less memory
• Confusing traversal directions
• Assuming singly linked lists allow backward traversal

2. Which of the following is the correct way to declare a node in a doubly linked list in C?

easy

A. struct Node { int data; struct Node* prev; };

B. struct Node { int data; struct Node* next; };

C. struct Node { int data; struct Node* prev; struct Node* next; };

D. struct Node { int data; int next; int prev; };

Solution

1. Step 1: Identify required pointers for doubly linked list node

   A doubly linked list node must have pointers to both previous and next nodes.

2. Step 2: Check each option

   struct Node { int data; struct Node* prev; struct Node* next; }; correctly declares both prev and next pointers as struct Node pointers.

3. Final Answer:

   struct Node { int data; struct Node* prev; struct Node* next; }; -> Option C

4. Quick Check:

   Node pointers = prev and next [OK]

Hint: Doubly linked nodes have both prev and next pointers [OK]

Common Mistakes:

• Omitting prev pointer
• Using int instead of pointer for next/prev
• Confusing singly linked list node with doubly linked

3. What will be the output of the following code snippet that uses a doubly linked list?

typedef struct Node {
  int data;
  struct Node* prev;
  struct Node* next;
} Node;

Node* head = NULL;

// Function to add node at end
void append(int val) {
  Node* newNode = (Node*)malloc(sizeof(Node));
  newNode->data = val;
  newNode->next = NULL;
  if (head == NULL) {
    newNode->prev = NULL;
    head = newNode;
    return;
  }
  Node* temp = head;
  while (temp->next != NULL) temp = temp->next;
  temp->next = newNode;
  newNode->prev = temp;
}

// Print list forward
void printForward() {
  Node* temp = head;
  while (temp != NULL) {
    printf("%d ", temp->data);
    temp = temp->next;
  }
}

int main() {
  append(10);
  append(20);
  append(30);
  printForward();
  return 0;
}

medium

A. 10 20 30

B. 30 20 10

C. 10 20

D. Compilation error

Solution

1. Step 1: Trace append function calls

   append(10) creates first node with data 10, head points to it. append(20) adds node with 20 at end. append(30) adds node with 30 at end.

2. Step 2: Trace printForward function

   printForward starts at head and prints data while moving next. It prints 10, then 20, then 30.

3. Final Answer:

   10 20 30 -> Option A

4. Quick Check:

   List forward print = 10 20 30 [OK]

Hint: Forward print shows nodes in insertion order [OK]

Common Mistakes:

• Confusing forward and backward traversal
• Assuming printForward prints in reverse
• Missing NULL checks causing errors

4. Identify the bug in the following code snippet that tries to delete the last node of a doubly linked list:

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

medium

A. No bug, code works correctly

B. Does not handle case when list has only one node

C. Incorrect pointer used for deletion

D. Memory leak due to missing free

Solution

1. Step 1: Analyze deletion logic

   The code finds last node by moving to node where next is NULL, then sets previous node's next to NULL and frees last node.

2. Step 2: Check edge case for single node list

   If list has only one node, temp->prev is NULL, so temp->prev->next causes a crash or undefined behavior.

3. Final Answer:

   Does not handle case when list has only one node -> Option B

4. Quick Check:

   Single node deletion needs special handling [OK]

Hint: Check for single node before accessing prev pointer [OK]

Common Mistakes:

• Ignoring single node edge case
• Assuming prev pointer always exists
• Not freeing memory after deletion

5. You want to implement a feature that allows moving backward through a list of recently opened files in a text editor. Which linked list type is best and why?

hard

A. Doubly linked list, because it allows moving backward and forward easily

B. Singly linked list, because it uses less memory and is simpler

C. Circular singly linked list, because it loops infinitely

D. Array, because linked lists cannot move backward

Solution

1. Step 1: Understand feature requirements

   The feature requires moving backward and forward through the list of files.

2. Step 2: Match data structure capabilities

   Singly linked lists allow only forward traversal, arrays allow random access but not efficient insertion/deletion, doubly linked lists allow easy backward and forward traversal.

3. Step 3: Evaluate options

   Doubly linked list fits best because it supports moving backward and forward efficiently.

4. Final Answer:

   Doubly linked list, because it allows moving backward and forward easily -> Option A

5. Quick Check:

   Backward traversal = Doubly linked list [OK]

Hint: Backward navigation needs doubly linked list [OK]

Common Mistakes:

• Choosing singly linked list for backward moves
• Ignoring traversal needs
• Assuming arrays handle backward traversal efficiently