Why Doubly Linked List Over Singly Linked List in DSA Typescript - Test Your Knowledge

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a node with a pointer to the next node only.

DSA Typescript

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

Drag options to blanks, or click blank then click option'

Anull

Bundefined

C0

Dthis

Attempts:

3 left

💡 Hint

Common Mistakes

Setting next to undefined or 0 instead of null.

Assigning next to this, which causes a circular reference.

The next pointer should start as null because the node does not point to any other node yet.

2fill in blank

medium

Complete the code to add a previous pointer in a doubly linked list node.

DSA Typescript

class DoublyNode {
  value: number;
  next: DoublyNode | null;
  prev: DoublyNode | null;
  constructor(value: number) {
    this.value = value;
    this.next = null;
    this.prev = [1];
  }
}

Drag options to blanks, or click blank then click option'

A0

Bundefined

Cthis

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Setting prev to undefined or 0 instead of null.

Assigning prev to this, causing self-reference.

The previous pointer should start as null because the node does not have a previous node yet.

3fill in blank

hard

Fix the error in the method that moves backward in a doubly linked list.

DSA Typescript

moveBackward(node: DoublyNode | null): number[] {
  const values: number[] = [];
  while (node !== null) {
    values.push(node.value);
    node = node.[1];
  }
  return values;
}

Drag options to blanks, or click blank then click option'

Anext

Bprevious

Cprev

Dback

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'next' instead of 'prev' to move backward.

Using incorrect property names like 'previous' or 'back'.

To move backward in a doubly linked list, use the prev pointer.

4fill in blank

hard

Fill both blanks to insert a new node after a given node in a doubly linked list.

DSA Typescript

insertAfter(node: DoublyNode, newNode: DoublyNode): void {
  newNode.prev = node;
  newNode.next = node.[1];
  if (node.[2] !== null) {
    node.[2].prev = newNode;
  }
  node.next = newNode;
}

Drag options to blanks, or click blank then click option'

Anext

Bprev

Cprevious

Dback

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' instead of 'next' for the newNode's next pointer.

Not updating the next node's prev pointer.

To insert after a node, set newNode's next to node's next, and if node's next exists, update its prev to newNode.

5fill in blank

hard

Fill all three blanks to remove a node from a doubly linked list.

DSA Typescript

remove(node: DoublyNode): void {
  if (node.[1] !== null) {
    node.[1].prev = node.[2];
  }
  if (node.[3] !== null) {
    node.[3].next = node.[2];
  }
}

Drag options to blanks, or click blank then click option'

Anext

Bprev

Cprevious

Dback

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up next and prev pointers.

Not checking for null before updating pointers.

When removing a node, link its next node's prev to its prev, and its prev node's next to its next.

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