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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a simple array of integers.

DSA C#

int[] numbers = new int[1]5;

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

A(5)

B[5]

C{5}

D<5>

Attempts:

3 left

💡 Hint

Common Mistakes

Using parentheses or curly braces instead of square brackets.

In C#, arrays are declared using square brackets []. So to create an array of size 5, we use new int[5].

2fill in blank

medium

Complete the code to add a new node to the end of a singly linked list.

DSA C#

currentNode.[1] = newNode;

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

ANext

BAdd

CInsert

DChild

Attempts:

3 left

💡 Hint

Common Mistakes

Using Add or Insert which are not properties of a node.

In a singly linked list, each node points to the next node using the Next property.

3fill in blank

hard

Fix the error in the tree node class to correctly define the list of children nodes.

DSA C#

public List<TreeNode> [1] = new List<TreeNode>();

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

Achildren

Bchild

Cnext

Dnodes

Attempts:

3 left

💡 Hint

Common Mistakes

Using singular 'child' for a list of nodes.

The list of child nodes in a tree is commonly named children to represent multiple nodes.

4fill in blank

hard

Fill both blanks to create a method that returns the number of children a tree node has.

DSA C#

public int GetChildCount() {
    return [1].[2];
}

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

Achildren

BCount

CLength

DSize

Attempts:

3 left

💡 Hint

Common Mistakes

Using Length or Size which are not properties of List in C#.

The children list has a property Count that returns how many child nodes it contains.

5fill in blank

hard

Fill all three blanks to create a method that adds a new child node to a tree node.

DSA C#

public void AddChild(TreeNode [1]) {
    [2].[3]([1]);
}

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

Achild

Bchildren

CAdd

DInsert

Attempts:

3 left

💡 Hint

Common Mistakes

Using Insert instead of Add.

Using wrong variable names.

The method takes a parameter named child, then calls Add on the children list to add the new 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