Why Doubly Linked List Over Singly Linked List in DSA Typescript - See It Work

Why Doubly Linked List Over Singly Linked List

📖 Scenario: Imagine you have a train with carriages connected in a line. You want to move forward and backward easily between carriages. A singly linked list is like a train where you can only move forward. A doubly linked list lets you move both forward and backward.

🎯 Goal: You will create a simple doubly linked list and see how it helps to move backward easily, unlike a singly linked list.

📋 What You'll Learn

Create a doubly linked list with three nodes containing values 10, 20, and 30

Add a variable to hold the current node starting at the head

Move the current node forward to the next node

Move the current node backward to the previous node

Print the value of the current node after moving forward and backward

💡 Why This Matters

🌍 Real World

Doubly linked lists are used in music players to move to the next or previous song easily, or in browsers to go forward and backward in history.

💼 Career

Understanding doubly linked lists helps in jobs involving data structure design, memory management, and building efficient navigation systems.

1

Create a doubly linked list with three nodes

Create three variables called node1, node2, and node3. Each should be an object with value, next, and prev properties. Set their values to 10, 20, and 30 respectively. Link them so that node1.next is node2, node2.next is node3, and node2.prev is node1, node3.prev is node2. Set node1.prev and node3.next to null.

DSA Typescript

# Your code here

Hint

Each node is an object with value, next, and prev. Link them forward and backward.

2

Add a variable to hold the current node starting at the head

Create a variable called current and set it to node1.

DSA Typescript

const node1 = { value: 10, next: null, prev: null };
const node2 = { value: 20, next: null, prev: null };
const node3 = { value: 30, next: null, prev: null };

node1.next = node2;
node2.prev = node1;
node2.next = node3;
node3.prev = node2;

node1.prev = null;
node3.next = null;

// Create a variable called current and set it to node1
# Your code here

Hint

Set current to the first node, node1.

3

Move the current node forward to the next node

Change the variable current to point to the next node by setting current to current.next.

DSA Typescript

const node1 = { value: 10, next: null, prev: null };
const node2 = { value: 20, next: null, prev: null };
const node3 = { value: 30, next: null, prev: null };

node1.next = node2;
node2.prev = node1;
node2.next = node3;
node3.prev = node2;

node1.prev = null;
node3.next = null;

const current = node1;

// Move current to the next node
# Your code here

Hint

Set current to current.next to move forward.

4

Move the current node backward to the previous node and print the value

Change the variable current to point to the previous node by setting current to current.prev. Then print the value of current.value using console.log.

DSA Typescript

const node1 = { value: 10, next: null, prev: null };
const node2 = { value: 20, next: null, prev: null };
const node3 = { value: 30, next: null, prev: null };

node1.next = node2;
node2.prev = node1;
node2.next = node3;
node3.prev = node2;

node1.prev = null;
node3.next = null;

let current = node1;

current = current.next;

// Move current to the previous node and print current.value
# Your code here

Hint

Set current to current.prev to move backward. Then print current.value.

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