Tree vs Array vs Linked List When Hierarchy Matters in DSA Typescript - Interactive Comparison Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a simple tree node with a value.

DSA Typescript

class TreeNode {
  value: number;
  children: TreeNode[];
  constructor(value: number) {
    this.value = value;
    this.children = [1];
  }
}

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

Anull

B{}

C[]

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using {} instead of [] for children.

Setting children to null or 0.

The children property should be an empty array to hold child nodes.

2fill in blank

medium

Complete the code to add a child node to a tree node.

DSA Typescript

function addChild(parent: TreeNode, child: TreeNode): void {
  parent.children.[1](child);
}

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

Apush

Bshift

Cpop

Dunshift

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop which removes the last element.

Using shift or unshift which affect the start of the array.

push adds the child node to the end of the children array.

3fill in blank

hard

Fix the error in the linked list node definition to correctly link nodes.

DSA Typescript

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

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

Aboolean

Bnumber

Cstring

DListNode

Attempts:

3 left

💡 Hint

Common Mistakes

Using primitive types like number or string for next.

Forgetting to allow null for the last node.

The next property should be of type ListNode to link to the next node.

4fill in blank

hard

Fill both blanks to create a function that converts an array to a linked list.

DSA Typescript

function arrayToLinkedList(arr: number[]): ListNode | null {
  if (arr.length === 0) return null;
  const head = new ListNode(arr[0]);
  let current = head;
  for (let i = 1; i [1] arr.length; i++) {
    current.next = new ListNode(arr[[2]]);
    current = current.next;
  }
  return head;
}

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

A<

Bi

C<=

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using <= causes out-of-bounds error.

Using 0 instead of i for array index.

The loop runs while i < arr.length and uses arr[i] to create new nodes.

5fill in blank

hard

Fill both blanks to create a function that prints tree values in preorder.

DSA Typescript

function preorder(node: TreeNode | null): void {
  if (node === null) return;
  console.log(node.[1]);
  for (const child of node.[2]) {
    preorder(child);
  }
}

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

Avalue

Bchildren

C)

D(

Attempts:

3 left

💡 Hint

Common Mistakes

Missing parentheses in recursive call.

Using wrong property names.

Print node.value, loop over node.children, and call preorder(child) with parentheses.

Practice

1. Which data structure is best suited to represent hierarchical relationships like a family tree or company organization?

easy

A. Tree

B. Array

C. Linked List

D. Stack

Solution

1. Step 1: Understand hierarchy representation

   Hierarchies have parent-child relationships, which are naturally modeled by trees.

2. Step 2: Compare data structures

   Arrays and linked lists are linear and do not represent branching well, unlike trees.

3. Final Answer:

   Tree -> Option A

4. Quick Check:

   Hierarchy = Tree [OK]

Hint: Hierarchy means branching, so choose Tree [OK]

Common Mistakes:

• Choosing Array because it's simple
• Choosing Linked List thinking it can represent hierarchy
• Confusing Stack with hierarchical structure

2. Which of the following is the correct TypeScript syntax to declare a simple linked list node with a value and a next pointer?

easy

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

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

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

D. class Node { value: number; next: any; constructor(value: number) { this.value = value; this.next = undefined; } }

Solution

1. Step 1: Check next pointer type

   Next pointer should allow either another Node or null to mark list end.

2. Step 2: Verify constructor initialization

   Constructor sets value and initializes next to null correctly.

3. Final Answer:

   class Node { value: number; next: Node | null; constructor(value: number) { this.value = value; this.next = null; } } -> Option B

4. Quick Check:

   Next pointer = Node or null [OK]

Hint: Next pointer must allow null for list end [OK]

Common Mistakes:

• Not allowing null for next pointer
• Initializing next as undefined instead of null
• Using any type which loses type safety

3. Given the following TypeScript code, what will be the printed output?

class TreeNode {
  value: number;
  children: TreeNode[];
  constructor(value: number) {
    this.value = value;
    this.children = [];
  }
}

const root = new TreeNode(1);
const child1 = new TreeNode(2);
const child2 = new TreeNode(3);
root.children.push(child1, child2);
console.log(root.children.map(c => c.value));

medium

A. [1, 2, 3]

B. Error: children is not iterable

C. [[2], [3]]

D. [2, 3]

Solution

1. Step 1: Understand tree structure

   Root node has value 1 and two children with values 2 and 3.

2. Step 2: Analyze console.log output

   Mapping children array extracts values [2, 3], root's value 1 is not included.

3. Final Answer:

   [2, 3] -> Option D

4. Quick Check:

   Children values = [2, 3] [OK]

Hint: Mapping children prints their values, not root's [OK]

Common Mistakes:

• Including root value in output
• Expecting nested arrays instead of flat array
• Assuming children is not iterable

4. Identify the bug in this TypeScript code that tries to create a linked list and print its values:

class Node {
  value: number;
  next: Node | null;
  constructor(value: number) {
    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;
while (current !== null) {
  console.log(current.value);
  current = current.next.next;
}

medium

A. Using console.log inside loop is invalid

B. Incorrect constructor syntax

C. Accessing next.next without checking if next is null

D. Node class missing a previous pointer

Solution

1. Step 1: Trace the while loop iteration

   Loop moves current by current.next.next, skipping nodes and risking null access.

2. Step 2: Identify null pointer risk

   When current.next is null, accessing current.next.next causes runtime error.

3. Final Answer:

   Accessing next.next without checking if next is null -> Option C

4. Quick Check:

   Null check missing before next.next access [OK]

Hint: Always check next before accessing next.next [OK]

Common Mistakes:

• Ignoring null checks causing runtime errors
• Thinking constructor syntax is wrong
• Believing console.log causes errors

5. You need to represent a company's organizational chart where each employee can have multiple direct reports. Which data structure should you use and why? Choose the best option and explain your reasoning.

hard

A. Tree, because it naturally models hierarchical relationships with multiple children

B. Linked List, because it allows dynamic insertion and deletion of employees

C. Stack, because it supports last-in-first-out operations suitable for reporting

D. Array, because it stores elements in order and is easy to access by index

Solution

1. Step 1: Analyze the problem requirements

   Organizational chart has hierarchy with employees having multiple direct reports (children).

2. Step 2: Match data structure to hierarchy

   Tree structure supports nodes with multiple children, representing managers and their reports well.

3. Step 3: Evaluate other options

   Array and linked list are linear and do not represent branching; stack is for LIFO, not hierarchy.

4. Final Answer:

   Tree, because it naturally models hierarchical relationships with multiple children -> Option A

5. Quick Check:

   Hierarchy with multiple children = Tree [OK]

Hint: Hierarchy with multiple children means Tree is best [OK]

Common Mistakes:

• Choosing Array for hierarchy
• Thinking Linked List handles multiple children well
• Confusing Stack with hierarchical data