Why Doubly Linked List Over Singly Linked List in DSA Typescript - Performance Analysis

Time Complexity: Why Doubly Linked List Over Singly Linked List

O(n) traversal, O(1) deletion in doubly linked list, O(n) deletion in singly linked list

Understanding Time Complexity

We want to understand how using a doubly linked list changes the time it takes to do common operations compared to a singly linked list.

Which operations become faster or slower, and why?

Scenario Under Consideration

Analyze the time complexity of traversing and deleting nodes in singly vs doubly linked lists.

class Node {
  value: number;
  next: Node | null;
  prev: Node | null; // only in doubly linked list
  constructor(value: number) {
    this.value = value;
    this.next = null;
    this.prev = null;
  }
}

// Example: delete a node when given a pointer to it
function deleteNode(node: Node) {
  if (node.prev) node.prev.next = node.next;
  if (node.next) node.next.prev = node.prev;
}

This code shows how a node is deleted in a doubly linked list using both next and prev pointers.

Identify Repeating Operations

Look at what operations repeat when traversing or deleting nodes.

• Primary operation: Moving from one node to the next (traversal).
• How many times: Up to n times for traversal through the list of size n.
• Deletion operation: In doubly linked list, deletion uses direct access to previous node; in singly linked list, it requires traversal to find previous node.

How Execution Grows With Input

Traversal takes time proportional to the number of nodes.

Input Size (n)	Traversal Steps	Deletion Steps (given node)
10	10 steps	Doubly: 1 step, Singly: up to 9 steps
100	100 steps	Doubly: 1 step, Singly: up to 99 steps
1000	1000 steps	Doubly: 1 step, Singly: up to 999 steps

Pattern observation: Traversal grows linearly with n in both lists, but deletion is constant time in doubly linked list and linear in singly linked list when previous node is unknown.

Final Time Complexity

Time Complexity: O(n) for traversal, O(1) for deletion in doubly linked list, O(n) for deletion in singly linked list.

This means doubly linked lists allow faster deletion when you have a pointer to the node, because you can access the previous node directly.

Common Mistake

[X] Wrong: "Doubly linked lists always take twice as long because they have two pointers per node."

[OK] Correct: While doubly linked lists use more memory, their operations like deletion can be faster because you don't need to search for the previous node, saving time especially in large lists.

Interview Connect

Understanding when to use doubly linked lists shows you know how to balance memory use and speed. This skill helps you choose the right tool for the job in real coding tasks.

Self-Check

"What if we only needed to traverse the list forward and never delete nodes? How would the time complexity difference between singly and doubly linked lists change?"

Practice

1. Why might you choose a doubly linked list over a singly linked list in a program?

easy

A. Because it uses less memory per node

B. Because it allows traversal in both directions easily

C. Because it is simpler to implement

D. Because it only stores one pointer per node

Solution

1. Step 1: Understand traversal capabilities

   A singly linked list allows moving forward only, while a doubly linked list allows moving forward and backward.

2. Step 2: Compare memory and complexity

   Doubly linked lists use more memory and are more complex but provide two-way traversal.

3. Final Answer:

   Because it allows traversal in both directions easily -> Option B

4. Quick Check:

   Two-way traversal = A [OK]

Hint: Doubly means two directions, singly means one [OK]

Common Mistakes:

• Thinking doubly linked lists use less memory
• Confusing simplicity with singly linked lists
• 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 TypeScript?

easy

A. class Node { value: number; next: Node; }

B. class Node { value: number; prev: Node; }

C. class Node { value: number; next: Node | null; prev: Node | null; }

D. class Node { value: number; next: Node | null; }

Solution

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

   A doubly linked list node must have both next and prev pointers, which can be null if no neighbor exists.

2. Step 2: Check TypeScript syntax for nullable pointers

   Using Node | null correctly allows for the end nodes to have null pointers.

3. Final Answer:

   class Node { value: number; next: Node | null; prev: Node | null; } -> Option C

4. Quick Check:

   Doubly linked node needs next and prev with nulls [OK]

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

Common Mistakes:

• Omitting the prev pointer
• Not allowing null for next or prev
• Using only one pointer like singly linked list

3. Consider this TypeScript code snippet for a doubly linked list node insertion at the front:

class Node {
  value: number;
  next: Node | null = null;
  prev: Node | null = null;
  constructor(value: number) { this.value = value; }
}

class DoublyLinkedList {
  head: Node | null = null;
  insertFront(value: number) {
    const newNode = new Node(value);
    if (this.head) {
      newNode.next = this.head;
      this.head.prev = newNode;
    }
    this.head = newNode;
  }
}

const list = new DoublyLinkedList();
list.insertFront(10);
list.insertFront(20);
list.insertFront(30);

let current = list.head;
const result = [];
while (current) {
  result.push(current.value);
  current = current.next;
}
console.log(result);

What will be printed?

medium

A. [10, 30, 20]

B. [10, 20, 30]

C. [20, 30, 10]

D. [30, 20, 10]

Solution

1. Step 1: Trace insertFront calls

   First insert 10: list is 10. Then insert 20 at front: list is 20 -> 10. Then insert 30 at front: list is 30 -> 20 -> 10.

2. Step 2: Traverse from head to next

   Starting at head (30), next is 20, then 10, then null. So collected values are [30, 20, 10].

3. Final Answer:

   [30, 20, 10] -> Option D

4. Quick Check:

   Insert front reverses order = [30, 20, 10] [OK]

Hint: Insert front adds new node before head [OK]

Common Mistakes:

• Assuming insertion appends at end
• Mixing order of traversal
• Ignoring prev pointer effects

4. This TypeScript code tries to delete the last node from a doubly linked list but has a bug:

deleteLast() {
  if (!this.head) return;
  let current = this.head;
  while (current.next) {
    current = current.next;
  }
  current.prev.next = null;
}

What is the bug here?

medium

A. It does not handle the case when list has only one node

B. It incorrectly sets current.next to null instead of current.prev.next

C. It causes infinite loop in the while

D. It deletes the head node instead of the last node

Solution

1. Step 1: Analyze deletion logic

   The code moves to the last node by following next pointers. Then it sets current.prev.next = null to remove last node.

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

   If list has only one node, current.prev is null, so current.prev.next causes error.

3. Final Answer:

   It does not handle the case when list has only one node -> Option A

4. Quick Check:

   Single node list needs special case [OK]

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

Common Mistakes:

• Ignoring single node edge case
• Assuming prev is always non-null
• Confusing next and prev pointers

5. You want to implement a feature that requires frequent backward traversal from any node in a list. Which data structure is best and why? Options: A) Singly linked list because it uses less memory B) Circular singly linked list because it loops infinitely C) Array because it supports random access D) Doubly linked list because it allows backward traversal efficiently

hard

A. Doubly linked list because it allows backward traversal efficiently

B. Circular singly linked list because it loops infinitely

C. Array because it supports random access

D. Singly linked list because it uses less memory

Solution

1. Step 1: Understand backward traversal need

   Backward traversal means moving from a node to its previous nodes efficiently.

2. Step 2: Compare data structures for backward traversal

   Singly linked lists do not have backward pointers. Arrays allow random access but not linked traversal. Circular singly linked lists loop but do not support backward traversal. Doubly linked lists have prev pointers for efficient backward moves.

3. Final Answer:

   Doubly linked list because it allows backward traversal efficiently -> Option A

4. Quick Check:

   Backward traversal needs prev pointers [OK]

Hint: Backward moves need prev pointers, only doubly linked lists have them [OK]

Common Mistakes:

• Choosing singly linked list for backward traversal
• Confusing arrays with linked lists
• Thinking circular singly linked lists support backward moves