Tree vs Array vs Linked List When Hierarchy Matters in DSA Typescript - Compare & Choose

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Traversing a Simple Tree Structure

What is the output of the following TypeScript code that traverses a simple tree and prints node values in preorder?

DSA Typescript

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);
child1.children.push(new TreeNode(4));

function preorder(node: TreeNode | null, result: number[] = []): number[] {
  if (!node) return result;
  result.push(node.value);
  for (const child of node.children) {
    preorder(child, result);
  }
  return result;
}

console.log(preorder(root).join(' -> ') + ' -> null');

A 1 -> 3 -> 2 -> 4 -> null

B 1 -> 2 -> 4 -> 3 -> null

C 4 -> 2 -> 3 -> 1 -> null

D 1 -> 2 -> 3 -> 4 -> null

💡 Hint

Preorder traversal visits the current node before its children, and children are visited in the order they appear.

The preorder traversal visits root first (1), then its first child (2), then 2's child (4), then the second child of root (3).

🧠 Conceptual

intermediate

Choosing Data Structure for Hierarchical Data

Which data structure is best suited to represent a company's organizational hierarchy where each employee can have multiple subordinates?

A Tree, because it naturally represents hierarchical relationships with parent and multiple children

B Array, because it stores elements in order and allows fast access by index

C Linked List, because it allows easy insertion and deletion of employees in a sequence

D Stack, because it manages elements in last-in-first-out order

💡 Hint

Think about how to represent multiple levels and branches of employees.

A tree structure is ideal for hierarchical data because each node can have multiple children representing subordinates.

🔧 Debug

advanced

Identify the Error in Linked List Node Insertion

What error will occur when running this TypeScript code that tries to insert a node at the head of a singly linked list?

DSA Typescript

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

let head: ListNode | null = null;

function insertAtHead(value: number) {
  const newNode = new ListNode(value);
  newNode.next = head;
  head = newNode;
}

insertAtHead(10);
insertAtHead(20);
console.log(head.next.value);

A 20

B undefined

C 10

D TypeError: Cannot read property 'value' of null

💡 Hint

Trace the insertions and what head.next points to after two insertions.

After inserting 10 then 20 at head, head points to 20, head.next points to 10, so head.next.value is 10.

❓ Predict Output

advanced

Output of Flattening a Tree into an Array

What is the output of this TypeScript code that flattens a tree into an array using depth-first search?

DSA Typescript

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

const root = new TreeNode(1);
const c1 = new TreeNode(2);
const c2 = new TreeNode(3);
const c3 = new TreeNode(4);
root.children.push(c1, c2);
c1.children.push(c3);

function flattenTree(node: TreeNode | null, arr: number[] = []): number[] {
  if (!node) return arr;
  arr.push(node.value);
  for (const child of node.children) {
    flattenTree(child, arr);
  }
  return arr;
}

console.log(flattenTree(root));

A [1, 2, 4, 3]

B [1, 3, 2, 4]

C [4, 2, 3, 1]

D [2, 4, 1, 3]

💡 Hint

Depth-first search visits node before children recursively.

The flattenTree function visits root (1), then child 2, then 2's child 4, then child 3.

🧠 Conceptual

expert

Why Not Use Array for Deep Hierarchical Data?

Why is using a simple array a poor choice to represent deeply nested hierarchical data compared to a tree or linked list?

A Arrays cannot store multiple data types, so they are unsuitable for hierarchy

B Arrays automatically sort elements, which breaks hierarchical order

C Arrays are slower than trees for all operations, so they are inefficient

D Arrays do not naturally represent parent-child relationships and require complex indexing to simulate hierarchy

💡 Hint

Think about how hierarchy needs explicit parent-child links.

Arrays store elements linearly and lack direct links to represent nested parent-child relationships, making hierarchy representation complex.