Create and Initialize Doubly Linked List in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new node with given value in a doubly linked list.

DSA Javascript

class Node {
  constructor(value) {
    this.value = value;
    this.prev = null;
    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 circular reference.

The next pointer of a new node should be initialized to null because it does not point to any node yet.

2fill in blank

medium

Complete the code to initialize the head of the doubly linked list with the first node.

DSA Javascript

class DoublyLinkedList {
  constructor() {
    this.head = [1];
    this.tail = null;
  }
}

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

Anull

Bnew Node(0)

Cundefined

Dnew Node(null)

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing head with a new node instead of null.

Using undefined instead of null.

The list is empty at creation, so head should be null.

3fill in blank

hard

Fix the error in the method that adds a new node at the end of the doubly linked list.

DSA Javascript

addToEnd(value) {
  const newNode = new Node(value);
  if (this.tail === null) {
    this.head = newNode;
    this.tail = newNode;
  } else {
    this.tail.next = newNode;
    newNode.prev = [1];
    this.tail = newNode;
  }
}

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

Athis.head

Bthis.tail

CnewNode

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Setting prev to head or newNode instead of tail.

Setting prev to null which breaks the link.

The new node's prev should point to the current tail before updating the tail.

4fill in blank

hard

Fill both blanks to complete the method that adds a new node at the beginning of the doubly linked list.

DSA Javascript

addToStart(value) {
  const newNode = new Node(value);
  if (this.head === null) {
    this.head = newNode;
    this.tail = newNode;
  } else {
    newNode.next = [1];
    [2].prev = newNode;
    this.head = newNode;
  }
}

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

Athis.head

Bthis.tail

CnewNode

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Using tail instead of head for next and prev pointers.

Setting prev of newNode instead of the old head.

The new node's next points to the current head, and the current head's prev points back to the new node.

5fill in blank

hard

Fill all three blanks to complete the method that prints all values from head to tail in the doubly linked list.

DSA Javascript

printList() {
  let current = this.head;
  while (current !== [1]) {
    console.log(current.[2]);
    current = current.[3];
  }
}

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

Anull

Bvalue

Cnext

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Using head instead of null to end the loop.

Printing next instead of value.

Moving current to prev instead of next.

The loop runs until current is null, printing the value of each node and moving to the next node.

Practice

1. What is the main difference between a doubly linked list and a singly linked list?

easy

A. A doubly linked list has nodes with pointers to both previous and next nodes.

B. A doubly linked list stores data in arrays instead of nodes.

C. A doubly linked list can only be traversed forward.

D. A doubly linked list does not use pointers at all.

Solution

1. Step 1: Understand node structure in doubly linked list

   Each node in a doubly linked list has two pointers: one to the next node and one to the previous node.

2. Step 2: Compare with singly linked list

   Singly linked list nodes have only one pointer to the next node, so they cannot go backward.

3. Final Answer:

   A doubly linked list has nodes with pointers to both previous and next nodes. -> Option A

4. Quick Check:

   Doubly linked list = two pointers per node [OK]

Hint: Remember: doubly linked means two directions [OK]

Common Mistakes:

• Thinking doubly linked lists use arrays
• Believing doubly linked lists only go forward
• Confusing pointers with data storage

2. Which of the following is the correct way to define a Node class for a doubly linked list in JavaScript?

easy

A. class Node { constructor(data) { this.data = data; this.next = null; } }

B. class Node { constructor(data) { this.data = data; this.prev = null; this.next = null; } }

C. class Node { constructor(data) { this.data = data; this.left = null; this.right = null; } }

D. class Node { constructor(data) { this.value = data; this.next = null; } }

Solution

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

   A doubly linked list node needs both 'prev' and 'next' pointers initialized to null.

2. Step 2: Check constructor parameters and properties

   class Node { constructor(data) { this.data = data; this.prev = null; this.next = null; } } correctly defines 'data', 'prev', and 'next' properties in the constructor.

3. Final Answer:

   class Node { constructor(data) { this.data = data; this.prev = null; this.next = null; } } -> Option B

4. Quick Check:

   Node needs prev and next pointers [OK]

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

Common Mistakes:

• Omitting the prev pointer
• Using wrong pointer names like left/right
• Using different property names for data

3. What will be the output of the following code snippet?

class Node {
  constructor(data) {
    this.data = data;
    this.prev = null;
    this.next = null;
  }
}

class DoublyLinkedList {
  constructor() {
    this.head = null;
    this.tail = null;
  }
  append(data) {
    const newNode = new Node(data);
    if (!this.head) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      this.tail.next = newNode;
      newNode.prev = this.tail;
      this.tail = newNode;
    }
  }
}

const list = new DoublyLinkedList();
list.append(1);
list.append(2);
list.append(3);

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

medium

A. []

B. [3, 2, 1]

C. [null, null, null]

D. [1, 2, 3]

Solution

1. Step 1: Append nodes 1, 2, 3 to the list

   Each append adds a new node at the tail, linking prev and next pointers correctly.

2. Step 2: Traverse from head to tail collecting data

   Starting at head (1), moving next collects 1, then 2, then 3, then stops at null.

3. Final Answer:

   [1, 2, 3] -> Option D

4. Quick Check:

   Traversal from head collects [1, 2, 3] [OK]

Hint: Traverse from head using next to get list order [OK]

Common Mistakes:

• Confusing traversal direction
• Not updating tail pointer on append
• Pushing null values instead of data

4. Identify the error in the following code that tries to append a node to a doubly linked list:

class Node {
  constructor(data) {
    this.data = data;
    this.prev = null;
    this.next = null;
  }
}

class DoublyLinkedList {
  constructor() {
    this.head = null;
    this.tail = null;
  }
  append(data) {
    const newNode = new Node(data);
    if (!this.head) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      this.tail.next = newNode;
      this.tail.prev = newNode;
      this.tail = newNode;
    }
  }
}

medium

A. The constructor is missing initialization of head and tail.

B. The newNode should not have prev or next pointers.

C. The line 'this.tail.prev = newNode;' should be 'newNode.prev = this.tail;'.

D. The append method should not update the tail pointer.

Solution

1. Step 1: Analyze pointer updates in append method

   When adding newNode, the previous tail's next should point to newNode, and newNode's prev should point to old tail.

2. Step 2: Identify incorrect pointer assignment

   The code incorrectly sets 'this.tail.prev = newNode;' which wrongly changes the old tail's prev pointer instead of newNode's prev pointer.

3. Final Answer:

   The line 'this.tail.prev = newNode;' should be 'newNode.prev = this.tail;'. -> Option C

4. Quick Check:

   Correct prev pointer must link newNode to old tail [OK]

Hint: Prev pointer goes from new node back to old tail [OK]

Common Mistakes:

• Swapping prev and next pointers
• Not updating newNode.prev correctly
• Forgetting to update tail pointer

5. You want to create a doubly linked list from an array of values [10, 20, 30] and then traverse it backward from tail to head. Which code snippet correctly initializes the list and prints the values backward?

hard

A. const list = new DoublyLinkedList();
for (const val of [10, 20, 30]) list.append(val);
let current = list.tail;
while (current) { console.log(current.data); current = current.prev; }

B. const list = new DoublyLinkedList();
for (let i = 2; i >= 0; i--) list.append([10, 20, 30][i]);
let current = list.head;
while (current) { console.log(current.data); current = current.next; }

C. const list = new DoublyLinkedList();
for (const val of [10, 20, 30]) list.append(val);
let current = list.head;
while (current) { console.log(current.data); current = current.prev; }

D. const list = new DoublyLinkedList();
for (const val of [10, 20, 30]) list.append(val);
let current = list.tail;
while (current) { console.log(current.data); current = current.next; }

Solution

1. Step 1: Append values in order to the list

   Using a for-of loop appends 10, then 20, then 30, building the list head to tail.

2. Step 2: Traverse backward from tail using prev pointer

   Starting at tail (30), moving prev prints 30, 20, 10 in reverse order.

3. Final Answer:

   const list = new DoublyLinkedList(); for (const val of [10, 20, 30]) list.append(val); let current = list.tail; while (current) { console.log(current.data); current = current.prev; } -> Option A

4. Quick Check:

   Backward traversal uses tail and prev pointer [OK]

Hint: Traverse backward from tail using prev pointer [OK]

Common Mistakes:

• Traversing backward from head
• Using next pointer to go backward
• Appending values in reverse order but traversing forward