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 node struct for a binary tree.

DSA C

typedef struct Node {
    int data;
    struct Node* [1];
    struct Node* right;
} Node;

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

Aprev

Bnext

Cleft

Dchild

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'next' or 'prev' which are common in linked lists, not trees.

Using 'child' which is too generic for binary trees.

The left child pointer in a binary tree node is typically named left.

2fill in blank

medium

Complete the code to access the third element in an integer array named arr.

DSA C

int value = arr[1];

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

A[2]

B[3]

C(2)

D(3)

Attempts:

3 left

💡 Hint

Common Mistakes

Using parentheses instead of square brackets for indexing.

Using index 3 which is the fourth element.

Array indexing in C starts at 0, so the third element is at index 2.

3fill in blank

hard

Fix the error in the linked list node insertion code by completing the blank.

DSA C

new_node->next = [1];
head = new_node;

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

Ahead

Bhead->next

CNULL

Dnew_node

Attempts:

3 left

💡 Hint

Common Mistakes

Pointing new_node->next to head->next which skips the first node.

Setting new_node->next to NULL which breaks the list.

To insert at the beginning, new_node's next should point to the current head.

4fill in blank

hard

Fill both blanks to create a function that returns the height of a binary tree.

DSA C

int height(Node* root) {
    if (root == NULL) return 0;
    int leftHeight = height(root->[1]);
    int rightHeight = height(root->[2]);
    return (leftHeight > rightHeight) ? leftHeight + 1 : rightHeight + 1;
}

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

Aleft

Bnext

Cright

Dchild

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'next' or 'child' which are not standard for binary trees.

Mixing up left and right pointers.

The height function recursively checks the left and right children of the node.

5fill in blank

hard

Fill all three blanks to create a function that counts nodes in a linked list.

DSA C

int countNodes(Node* head) {
    int count = 0;
    Node* current = head;
    while (current != [1]) {
        count[2];
        current = current->[3];
    }
    return count;
}

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

ANULL

B++

Cnext

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'head' instead of NULL to check loop end.

Forgetting to increment count or move current.

The loop runs until current is NULL, increments count, and moves current to next node.

Practice

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

easy

A. Stack

B. Array

C. Tree

D. Linked List

Solution

1. Step 1: Understand hierarchy representation

   Hierarchies have parent-child relationships, which trees represent naturally with nodes and branches.

2. Step 2: Compare with other structures

   Arrays and linked lists are linear and do not represent multiple branches from one node easily.

3. Final Answer:

   Tree -> Option C

4. Quick Check:

   Hierarchy = Tree [OK]

Hint: Hierarchy means branching; trees model branching best [OK]

Common Mistakes:

• Choosing array because it stores elements
• Choosing linked list assuming it can represent hierarchy
• Confusing stack with hierarchical structure

2. Which of the following is the correct way to declare a simple linked list node in C?

easy

A. struct Node { int data; struct Node* next; };

B. struct Node { int data; int next; };

C. struct Node { int data; Node next; };

D. struct Node { int data; struct Node next; };

Solution

1. Step 1: Check pointer usage in struct

   A linked list node must have a pointer to the next node, so 'struct Node* next' is correct.

2. Step 2: Identify incorrect declarations

   Options B, C, and D either use wrong types or missing pointers, causing errors.

3. Final Answer:

   struct Node { int data; struct Node* next; }; -> Option A

4. Quick Check:

   Pointer to next node = struct Node { int data; struct Node* next; }; [OK]

Hint: Linked list nodes need pointer to next node [OK]

Common Mistakes:

• Using int instead of pointer for next
• Omitting struct keyword in C
• Using struct Node next instead of pointer

3. What will be the output of the following C code that builds a simple tree node and prints its data?

typedef struct Node {
  int data;
  struct Node* left;
  struct Node* right;
} Node;

int main() {
  Node root = {10, NULL, NULL};
  printf("%d", root.data);
  return 0;
}

medium

A. Garbage value

B. 0

C. Compilation error

D. 10

Solution

1. Step 1: Analyze struct initialization

   The root node is initialized with data=10 and left/right pointers as NULL.

2. Step 2: Check printf output

   Printing root.data will output 10 as assigned.

3. Final Answer:

   10 -> Option D

4. Quick Check:

   root.data = 10 [OK]

Hint: Initialized struct fields print assigned values [OK]

Common Mistakes:

• Assuming uninitialized pointers affect data
• Expecting compilation error due to typedef
• Confusing pointer and value printing

4. Identify the error in this linked list insertion code snippet in C:

struct Node {
  int data;
  struct Node* next;
};

void insertAtFront(struct Node* head, int val) {
  struct Node* newNode = malloc(sizeof(struct Node));
  newNode->data = val;
  newNode->next = head;
  head = newNode;
}

medium

A. malloc size is incorrect

B. head is passed by value; changes won't affect original list

C. newNode->next should be NULL

D. Missing free() for old head

Solution

1. Step 1: Understand pointer passing in C

   head is passed by value, so assigning head = newNode only changes local copy.

2. Step 2: Effect on original list

   The original head pointer outside the function remains unchanged, so insertion fails.

3. Final Answer:

   head is passed by value; changes won't affect original list -> Option B

4. Quick Check:

   Pointer passed by value = head is passed by value; changes won't affect original list [OK]

Hint: Pass pointer by reference to modify original list [OK]

Common Mistakes:

• Thinking malloc size is wrong
• Assuming newNode->next must be NULL
• Confusing free() necessity here

5. You need to store a company's organizational chart where each manager can have multiple direct reports. Which data structure is best and why?

hard

A. Tree because it models hierarchical parent-child relationships

B. Linked List because it allows dynamic size

C. Array because it stores elements contiguously

D. Stack because it supports last-in-first-out access

Solution

1. Step 1: Understand organizational chart structure

   It is a hierarchy where managers have multiple direct reports (children).

2. Step 2: Match data structure to hierarchy

   Trees naturally represent such parent-child relationships with multiple branches.

3. Step 3: Evaluate other options

   Arrays and linked lists are linear and do not represent multiple children per node well; stacks are for LIFO access, not hierarchy.

4. Final Answer:

   Tree because it models hierarchical parent-child relationships -> Option A

5. Quick Check:

   Hierarchy with multiple children = Tree [OK]

Hint: Multiple children per node? Use tree structure [OK]

Common Mistakes:

• Choosing array for hierarchy
• Confusing linked list dynamic size with hierarchy
• Using stack for hierarchical data