Node Structure and Pointer Design in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Linked List Node Connections

What is the printed output of the linked list after running the following code?

DSA Javascript

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

const head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);

let current = head;
let output = '';
while (current) {
  output += current.value + ' -> ';
  current = current.next;
}
output += 'null';
console.log(output);

A 1 -> 2 -> 3 -> null

B 1 -> 3 -> 2 -> null

C 3 -> 2 -> 1 -> null

D null -> 1 -> 2 -> 3

💡 Hint

Trace the next pointers from the head node to the end.

The linked list nodes are connected in order: 1 points to 2, 2 points to 3, and 3 points to null. So the output prints values in sequence 1 -> 2 -> 3 -> null.

❓ Predict Output

intermediate

Output of Doubly Linked List Node Values

What is the output after running this doubly linked list traversal code?

DSA Javascript

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

const node1 = new Node(10);
const node2 = new Node(20);
const node3 = new Node(30);

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

let current = node3;
let output = '';
while (current) {
  output += current.value + ' <-> ';
  current = current.prev;
}
output += 'null';
console.log(output);

A 30 <-> 20 <-> 10 <-> null

B 10 <-> 20 <-> 30 <-> null

C null <-> 10 <-> 20 <-> 30

D 30 -> 20 -> 10 -> null

💡 Hint

Start from the last node and follow the prev pointers.

Starting from node3 (value 30), following prev pointers visits node2 (20) then node1 (10), then null. So output is 30 <-> 20 <-> 10 <-> null.

❓ Predict Output

advanced

Output of Circular Linked List Traversal

What will be printed by this code that traverses a circular linked list with 3 nodes?

DSA Javascript

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

const nodeA = new Node('A');
const nodeB = new Node('B');
const nodeC = new Node('C');

nodeA.next = nodeB;
nodeB.next = nodeC;
nodeC.next = nodeA; // circular link

let current = nodeA;
let output = '';
let count = 0;
while (count < 5) {
  output += current.value + ' -> ';
  current = current.next;
  count++;
}
output += '...';
console.log(output);

A SyntaxError

B A -> B -> C -> null

C A -> B -> C -> C -> C -> ...

D A -> B -> C -> A -> B -> ...

💡 Hint

The list loops back to the start after node C.

The circular link makes traversal repeat nodes A, B, C in a loop. The code prints 5 nodes then '...'. So output is A -> B -> C -> A -> B -> ...

🧠 Conceptual

advanced

Pointer Design in a Binary Tree Node

Which of the following correctly describes the pointers in a binary tree node structure?

A Each node has a pointer to the next sibling node only.

B Each node has a pointer to its parent only.

C Each node has two pointers: one to the left child and one to the right child.

D Each node has a pointer to all its descendants.

💡 Hint

Think about how binary trees branch.

A binary tree node typically has two pointers: left child and right child. Parent or sibling pointers are optional and not standard.

❓ Predict Output

expert

Output of Complex Linked List with Random Pointers

Given the following code with nodes having next and random pointers, what is the output of the printed values following the random pointers starting from head?

DSA Javascript

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

const node1 = new Node(5);
const node2 = new Node(10);
const node3 = new Node(15);

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

node1.random = node3;
node2.random = node1;
node3.random = node2;

let current = node1;
let output = '';
let count = 0;
while (current && count < 3) {
  output += current.value + ' -> ';
  current = current.random;
  count++;
}
output += 'null';
console.log(output);

A TypeError

B 5 -> 15 -> 10 -> null

C 5 -> 10 -> 15 -> null

D 5 -> 15 -> 15 -> null

💡 Hint

Follow the random pointers starting from node1.

Starting at node1 (5), random points to node3 (15), which random points to node2 (10), which random points to node1 but loop stops after 3 steps. So output is 5 -> 15 -> 10 -> null.

Practice

1. What does a next pointer in a linked list node represent?

easy

A. It points to the previous node in the list

B. It points to the next node in the list

C. It stores the data of the node

D. It holds the size of the list

Solution

1. Step 1: Understand the role of next pointer

   The next pointer in a linked list node is used to link the current node to the following node, creating a chain.

2. Step 2: Differentiate from other parts of the node

   The data is stored separately in the node, and the next pointer does not hold data or list size. It specifically points to the next node.

3. Final Answer:

   It points to the next node in the list -> Option B

4. Quick Check:

   next pointer = next node address [OK]

Hint: Remember: next always points forward in the list [OK]

Common Mistakes:

• Confusing next with data storage
• Thinking next points backward
• Assuming next holds list size

2. Which of the following is the correct way to create a node object with a value and next pointer in JavaScript?

easy

A. const node = { value: 5, next: null };

B. const node = (value: 5, next: null);

C. const node = [value = 5, next = null];

D. const node = { val = 5, pointer = null };

Solution

1. Step 1: Identify correct JavaScript object syntax

   JavaScript objects use curly braces with key-value pairs separated by colons, like { key: value }.

2. Step 2: Check each option's syntax

   const node = { value: 5, next: null }; uses correct object syntax with keys value and next. Options B and C use invalid syntax, and D uses wrong keys.

3. Final Answer:

   const node = { value: 5, next: null }; -> Option A

4. Quick Check:

   Object with keys and colons = correct syntax [OK]

Hint: Use curly braces and colons for object properties [OK]

Common Mistakes:

• Using parentheses instead of braces
• Using equal signs instead of colons
• Wrong property names like val or pointer

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

function Node(value) {
  this.value = value;
  this.next = null;
}

const first = new Node(1);
const second = new Node(2);
first.next = second;
console.log(first.next.value);

medium

A. undefined

B. 1

C. 2

D. null

Solution

1. Step 1: Understand node creation and linking

   Two nodes are created with values 1 and 2. The next of the first node points to the second node.

2. Step 2: Access the value of the node pointed by first.next

   first.next points to the second node, which has value 2, so first.next.value is 2.

3. Final Answer:

   2 -> Option C

4. Quick Check:

   first.next.value = 2 [OK]

Hint: Follow the next pointer to get the next node's value [OK]

Common Mistakes:

• Confusing first.value with first.next.value
• Expecting null instead of node value
• Not linking nodes before accessing next

4. Identify the error in the following code snippet for creating a linked list node:

function Node(value) {
  this.value = value;
  this.next = undefined;
}

const node = new Node(10);
console.log(node.next.value);

medium

A. The next pointer should be a number

B. Missing semicolon after new Node(10)

C. Node constructor should not use this

D. Accessing value of undefined causes error

Solution

1. Step 1: Analyze the next pointer initialization

   The next pointer is set to undefined, meaning it does not point to any node.

2. Step 2: Understand the error when accessing node.next.value

   Since node.next is undefined, trying to access value on it causes a runtime error.

3. Final Answer:

   Accessing value of undefined causes error -> Option D

4. Quick Check:

   Accessing property on undefined = error [OK]

Hint: Never access properties on null or undefined pointers [OK]

Common Mistakes:

• Assuming next can be undefined safely
• Thinking semicolon omission causes runtime error
• Believing this is invalid in constructor

5. You want to create a singly linked list with nodes containing values 1, 2, and 3 in order. Which code snippet correctly links the nodes?

hard

A. const n1 = { value: 1, next: null };
const n2 = { value: 2, next: null };
const n3 = { value: 3, next: null };
n1.next = n2;
n2.next = n3;

B. const n1 = { value: 1, next: null };
const n2 = { value: 2, next: null };
const n3 = { value: 3, next: null };
n3.next = n2;
n2.next = n1;

C. const n1 = { value: 1, next: null };
const n2 = { value: 2, next: null };
const n3 = { value: 3, next: null };
n1.next = n3;
n3.next = n2;

D. const n1 = { value: 1, next: null };
const n2 = { value: 2, next: null };
const n3 = { value: 3, next: null };
n2.next = n1;
n3.next = n2;

Solution

1. Step 1: Understand the order of nodes in a singly linked list

   The list should start at node with value 1, then point to node 2, then node 3, and finally null.

2. Step 2: Check the linking in each option

   const n1 = { value: 1, next: null }; const n2 = { value: 2, next: null }; const n3 = { value: 3, next: null }; n1.next = n2; n2.next = n3; links n1.next to n2 and n2.next to n3, which is correct. Other options link nodes in reverse or wrong order.

3. Final Answer:

   Option A links nodes in correct order 1 -> 2 -> 3 -> null -> Option A

4. Quick Check:

   Link nodes forward in order [OK]

Hint: Link each node's next to the next value in order [OK]

Common Mistakes:

• Linking nodes backward
• Skipping nodes in the chain
• Assigning next incorrectly