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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Traversing a Simple Tree Structure

What is the output of this C# code that prints the values of a simple tree using preorder traversal?

DSA C#

class Node {
    public int Value;
    public List<Node> Children = new List<Node>();
    public Node(int val) { Value = val; }
}

var root = new Node(1);
root.Children.Add(new Node(2));
root.Children.Add(new Node(3));
root.Children[0].Children.Add(new Node(4));

void Preorder(Node node) {
    Console.Write(node.Value + " ");
    foreach(var child in node.Children) {
        Preorder(child);
    }
}

Preorder(root);

A 1 2 4 3

B 1 3 2 4

C 1 2 3 4

D 1 4 2 3

💡 Hint

Preorder traversal visits the node first, then its children in order.

Preorder traversal prints the root node first, then recursively visits each child from left to right.

Here, root is 1, children are 2 and 3, and 2 has child 4.

🧠 Conceptual

intermediate

Choosing Data Structure for Hierarchical Data

Which data structure is best suited to represent hierarchical data with multiple levels and varying number of children per node?

A Stack, because it follows last-in-first-out order suitable for hierarchy

B Linked List, because it allows easy insertion and deletion of elements in a sequence

C Array, because it stores elements contiguously and allows fast index access

D Tree, because it naturally represents parent-child relationships and multiple children

💡 Hint

Think about how to represent multiple children and levels clearly.

Trees are designed to represent hierarchical data with nodes having multiple children and levels.

Arrays and linked lists are linear and do not naturally represent hierarchy.

🔧 Debug

advanced

Identify the Error in Linked List Hierarchy Representation

What error will this C# code produce when trying to represent a hierarchy using a singly linked list where each node points to its child?

DSA C#

class Node {
    public int Value;
    public Node Next;
    public Node(int val) { Value = val; }
}

var root = new Node(1);
root.Next = new Node(2);
root.Next.Next = new Node(3);
root.Next.Next.Next = root; // creates a cycle

Node current = root;
int count = 0;
while(current != null && count < 10) {
    Console.Write(current.Value + " ");
    current = current.Next;
    count++;
}

A The code throws a NullReferenceException

B The code runs and prints: 1 2 3

C The code runs and prints: 1 2 3 1 2 3 1 2 3 1

D The code throws a StackOverflowException

💡 Hint

Look at the line creating a cycle in the linked list.

The linked list has a cycle because root.Next.Next.Next points back to root.

The loop prints nodes until count reaches 10, so it prints repeating sequence 1 2 3 1 2 3 ...

❓ Predict Output

advanced

Output of Array Representing Tree Levels

Given this array representing tree nodes level-wise, what is the output of the code printing all nodes at level 2?

DSA C#

int[] treeLevels = {1, 2, 3, 4, 5, 6, 7};
// Level 0: 1
// Level 1: 2, 3
// Level 2: 4, 5, 6, 7

int level = 2;
int startIndex = (int)Math.Pow(2, level) - 1;
int endIndex = (int)Math.Pow(2, level + 1) - 2;

for(int i = startIndex; i <= endIndex && i < treeLevels.Length; i++) {
    Console.Write(treeLevels[i] + " ");
}

A 2 3 4 5

B 4 5 6 7

C 1 2 3

D 6 7

💡 Hint

Calculate start and end indices carefully for the given level.

Level 2 nodes start at index 3 and end at index 6 in the array.

These are values 4, 5, 6, 7.

🧠 Conceptual

expert

Why Trees Are Preferred Over Arrays or Linked Lists for Hierarchical Data

Which reason best explains why trees are preferred over arrays or linked lists when representing hierarchical data with complex parent-child relationships?

A Trees allow dynamic insertion and deletion of nodes at any level without shifting elements, unlike arrays.

B Arrays provide faster access to elements by index, making them better for hierarchy.

C Linked lists use less memory than trees, so they are preferred for hierarchy.

D Trees store data contiguously in memory, improving cache performance over linked lists.

💡 Hint

Think about flexibility and structure in hierarchical data.

Trees allow nodes to be added or removed anywhere without reorganizing the entire structure.

Arrays require shifting elements, and linked lists do not naturally represent multiple children per node.

Practice

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

easy

A. Linked List

B. Array

C. Tree

D. Stack

Solution

1. Step 1: Identify best structure for hierarchical relationships

   Hierarchies have parent-child relationships, which are naturally modeled by trees. Arrays and linked lists are linear and do not represent branching well, unlike trees.

2. Final Answer:

   Tree -> Option C

3. 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 branch
• Confusing Stack with hierarchical structure

2. Which of the following is the correct way to declare a simple array of integers in C#?

easy

A. int[] numbers = new int[5];

B. int numbers = new int[5];

C. int numbers[] = new int(5);

D. array numbers = int[5];

Solution

1. Step 1: Recall and verify C# array declaration syntax

   Arrays are declared with type[], variable name, and new type[size]. int[] numbers = new int[5]; matches; others have syntax errors.

2. Final Answer:

   int[] numbers = new int[5]; -> Option A

3. Quick Check:

   C# array syntax = int[] numbers = new int[5]; [OK]

Hint: Remember C# arrays use type[] variable = new type[size]; [OK]

Common Mistakes:

• Missing [] after type
• Using parentheses instead of brackets
• Incorrect variable declaration without type[]

3. Consider the following C# code that creates a simple tree node class and adds children:

using System;
using System.Collections.Generic;
class Node {
  public string Name;
  public List<Node> Children = new List<Node>();
  public Node(string name) { Name = name; }
}

var root = new Node("Root");
var child1 = new Node("Child1");
var child2 = new Node("Child2");
root.Children.Add(child1);
root.Children.Add(child2);
Console.WriteLine(root.Children[1].Name);

What will be printed?

medium

A. "Child1"

B. Runtime error

C. "Root"

D. "Child2"

Solution

1. Step 1: Trace list indexing and code execution

   Children list: index 0=Child1, index 1=Child2. root.Children[1].Name = "Child2".

2. Final Answer:

   "Child2" -> Option D

3. Quick Check:

   Index 1 child name = "Child2" [OK]

Hint: List index 1 means second child, so output is Child2 [OK]

Common Mistakes:

• Confusing index 0 and 1
• Thinking root's name prints
• Expecting runtime error due to list usage

4. The following C# code attempts to create a linked list node and link two nodes:

using System;
class Node {
  public int Value;
  public Node Next;
  public Node(int val) { Value = val; }
}

Node first = new Node(1);
Node second = new Node(2);
first.Next = second;
second.Next = first;
Console.WriteLine(first.Next.Next.Value);

What is the problem with this code?

medium

A. It causes a null reference exception

B. It creates a circular linked list causing infinite loops

C. It does not link nodes correctly

D. It will not compile due to syntax errors

Solution

1. Step 1: Analyze node linking and consequences

   first.Next=second; second.Next=first forms a circular list, causing infinite loops if traversed without checks.

2. Final Answer:

   It creates a circular linked list causing infinite loops -> Option B

3. Quick Check:

   Circular link = infinite loop risk [OK]

Hint: Check if Next points back to previous node causing loops [OK]

Common Mistakes:

• Assuming null reference error
• Thinking nodes are not linked
• Ignoring circular reference issues

5. You need to store a company's organizational chart where each employee can have multiple subordinates, and you want to quickly find an employee's manager. Which data structure combination is best to represent this hierarchy efficiently in C#?

hard

A. Use a tree where each node has a list of children and a reference to its parent node

B. Use an array of employees with indexes representing hierarchy levels

C. Use a singly linked list where each node points to the next employee

D. Use a stack to push and pop employees as you traverse the hierarchy

Solution

1. Step 1: Match requirements to data structure features

   Multiple subordinates (children list) + quick manager lookup (parent ref) = tree with bidirectional links. Others lack branching or parent access.

2. Final Answer:

   Use a tree where each node has a list of children and a reference to its parent node -> Option A

3. Quick Check:

   Parent and children links = Tree with parent ref [OK]

Hint: Parent and children links need tree nodes with parent pointers [OK]

Common Mistakes:

• Choosing array which lacks parent info
• Using linked list which is linear only
• Confusing stack usage with storage