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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a node struct for a tree with a value and children.

DSA Go

type Node struct {
    Value int
    Children [][1]
}

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

A*Node

Bint

Cstring

Dbool

Attempts:

3 left

💡 Hint

Common Mistakes

Using int or string instead of Node for Children slice.

Forgetting to use a slice type for multiple children.

The Children field should be a slice of Node structs to represent child nodes in the tree.

2fill in blank

medium

Complete the code to append a child node to a parent node's Children slice.

DSA Go

parent.Children = append(parent.Children, [1])

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

Aparent

Bchild

CChildren

DValue

Attempts:

3 left

💡 Hint

Common Mistakes

Appending the parent node to its own children.

Appending the Children slice instead of a node.

We append the child node variable to the parent's Children slice.

3fill in blank

hard

Fix the error in this function that prints all node values in a tree recursively.

DSA Go

func printTree(node *Node) {
    if node == nil {
        return
    }
    fmt.Println(node.Value)
    for _, child := range node.[1] {
        printTree(child)
    }
}

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

ANodes

BValue

Cparent

DChildren

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong field name for children.

Trying to iterate over a non-slice field.

We must iterate over the Children slice to visit each child node.

4fill in blank

hard

Fill both blanks to create a linked list node struct with a value and pointer to next node.

DSA Go

type ListNode struct {
    Value int
    [1] *[2]
}

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

ANext

BListNode

CChild

DNode

Attempts:

3 left

💡 Hint

Common Mistakes

Using Child instead of Next for linked list.

Using Node instead of ListNode for pointer type.

The linked list node has a Next pointer to another ListNode struct.

5fill in blank

hard

Fill all three blanks to create a map from string keys to int values for counting frequencies.

DSA Go

freq := map[[1]][2]{}
for _, word := range words {
    freq[word][3] freq[word] + 1
}

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

Astring

Bint

C=

Dfloat64

Attempts:

3 left

💡 Hint

Common Mistakes

Using float64 instead of int for counts.

Using wrong operator like += instead of =.

The map keys are strings, values are ints, and we assign updated counts with =.

Practice

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

easy

A. Tree

B. Array

C. Linked List

D. Hash Map

Solution

1. Step 1: Understand hierarchy representation

   Hierarchies require parent-child relationships, which trees naturally represent.

2. Step 2: Compare data structures

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

3. Final Answer:

   Tree -> Option A

4. Quick Check:

   Hierarchy needs branching = Tree [OK]

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

Common Mistakes:

• Choosing array for hierarchy
• Confusing linked list with tree
• Ignoring parent-child links

2. Which of the following is the correct way to declare a slice of integers in Go?

easy

A. var nums [5]int

B. var nums (int)

C. var nums int[]

D. var nums []int

Solution

1. Step 1: Recall Go slice syntax

   Slices are declared with [] before the type, like []int.

2. Step 2: Check options

   var nums []int uses var nums []int which is correct slice declaration.

3. Final Answer:

   var nums []int -> Option D

4. Quick Check:

   Slice syntax = []type [OK]

Hint: Slices use []type syntax, arrays use [size]type [OK]

Common Mistakes:

• Using array syntax for slices
• Placing brackets after type
• Using parentheses instead of brackets

3. Consider the following Go code that builds a simple tree node struct and links children:

package main
import "fmt"

type Node struct {
    value int
    children []*Node
}

func main() {
    root := &Node{value: 1}
    child1 := &Node{value: 2}
    child2 := &Node{value: 3}
    root.children = append(root.children, child1, child2)
    fmt.Println(root.children[1].value)
}

What is the output of this program?

medium

A. 3

B. 2

C. 1

D. Compilation error

Solution

1. Step 1: Understand tree node structure

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

2. Step 2: Trace the print statement

   root.children[1] accesses second child, which has value 3, so prints 3.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   Second child value = 3 [OK]

Hint: Index 1 in children slice is second child [OK]

Common Mistakes:

• Confusing index 0 and 1
• Assuming root value prints
• Thinking children is a single node

4. The following Go code attempts to create a linked list node and print its value:

package main
import "fmt"

type Node struct {
    value int
    next *Node
}

func main() {
    node := Node{value: 10}
    fmt.Println(node.next.value)
}

What is the issue with this code?

medium

A. Missing import for fmt package

B. Syntax error in struct declaration

C. node.next is nil, accessing value causes runtime panic

D. node.value is uninitialized

Solution

1. Step 1: Analyze node initialization

   node.next is not set, so it is nil by default.

2. Step 2: Accessing node.next.value

   Accessing value on nil pointer causes runtime panic (nil dereference).

3. Final Answer:

   node.next is nil, accessing value causes runtime panic -> Option C

4. Quick Check:

   Nil pointer access causes panic [OK]

Hint: Check for nil before accessing pointer fields [OK]

Common Mistakes:

• Ignoring nil pointer dereference
• Assuming default values for pointers
• Missing import is not the main issue

5. You need to store a company's organizational chart where each employee can have multiple direct reports. Which data structure is best and why? Options: A) Use an array because it stores elements contiguously. B) Use a tree because it naturally models hierarchical relationships. C) Use a linked list because it allows easy insertion. D) Use a hash map because it provides fast lookups.

medium

A. Use an array because it stores elements contiguously.

B. Use a tree because it naturally models hierarchical relationships.

C. Use a linked list because it allows easy insertion.

D. Use a hash map because it provides fast lookups.

Solution

1. Step 1: Understand organizational chart structure

   It is hierarchical with multiple direct reports per employee.

2. Step 2: Evaluate data structure suitability

   Arrays and linked lists are linear, not hierarchical. Hash maps are for key-value pairs, not hierarchy.

3. Step 3: Choose tree for hierarchy

   Trees model parent-child relationships naturally, perfect for org charts.

4. Final Answer:

   Use a tree because it naturally models hierarchical relationships. -> Option B

5. Quick Check:

   Hierarchy needs tree structure [OK]

Hint: Hierarchy means tree; arrays and lists are linear [OK]

Common Mistakes:

• Choosing array or list for hierarchy
• Confusing fast lookup with hierarchy modeling
• Ignoring multiple children per node