Tree vs Array vs Linked List When Hierarchy Matters in DSA Go - Build Both Approaches

Tree vs Array vs Linked List When Hierarchy Matters

📖 Scenario: Imagine you are organizing a company's employee structure. Each employee has a name and may have subordinates reporting to them. You want to represent this hierarchy in different ways to understand how data structures like arrays, linked lists, and trees can store hierarchical data.

🎯 Goal: You will create three different data structures in Go to represent the same employee hierarchy: an array, a linked list, and a tree. You will then print the structure to see how hierarchy is maintained or lost in each case.

📋 What You'll Learn

Create an array of employee names representing a flat list of employees.

Create a singly linked list of employee names representing a chain of command.

Create a tree structure where each employee node can have multiple subordinates.

Print each data structure to show how hierarchy is represented.

💡 Why This Matters

🌍 Real World

Hierarchical data structures like trees are used in organizations, file systems, and menus where relationships matter.

💼 Career

Understanding how to represent and traverse hierarchical data is essential for software developers working with complex data models.

1

Create an array of employee names

Create a variable called employeesArray which is a slice of strings containing these exact employee names in order: "CEO", "Manager", "Lead", "Developer".

DSA Go

# Create a slice of strings called employeesArray with the names "CEO", "Manager", "Lead", "Developer"
// Your code here

Hint

Use a slice literal with the exact employee names in order.

2

Create a singly linked list of employees

Add a struct type called EmployeeNode with fields name string and next *EmployeeNode. Then create variables head, node2, node3, and node4 of type *EmployeeNode representing employees "CEO", "Manager", "Lead", and "Developer" respectively. Link them in order so that head points to "CEO" and each node's next points to the next employee.

DSA Go

package main

import "fmt"

type EmployeeNode struct {
    name string
    next *EmployeeNode
}

func main() {
    employeesArray := []string{"CEO", "Manager", "Lead", "Developer"}

    // Create linked list nodes and link them
    // Your code here
}

Hint

Define the struct first, then create nodes with &EmployeeNode{...} and link them using the next field.

3

Create a tree structure for employee hierarchy

Add a struct type called EmployeeTreeNode with fields name string and subordinates []*EmployeeTreeNode. Create nodes for "CEO", "Manager", "Lead", and "Developer". Set up the hierarchy so that "CEO" has "Manager" as subordinate, "Manager" has "Lead" as subordinate, and "Lead" has "Developer" as subordinate.

DSA Go

package main

import "fmt"

type EmployeeNode struct {
    name string
    next *EmployeeNode
}

type EmployeeTreeNode struct {
    name string
    subordinates []*EmployeeTreeNode
}

func main() {
    employeesArray := []string{"CEO", "Manager", "Lead", "Developer"}

    head := &EmployeeNode{name: "CEO"}
    node2 := &EmployeeNode{name: "Manager"}
    node3 := &EmployeeNode{name: "Lead"}
    node4 := &EmployeeNode{name: "Developer"}

    head.next = node2
    node2.next = node3
    node3.next = node4

    // Create tree nodes and set hierarchy
    // Your code here
}

Hint

Define the tree node struct with a slice of pointers for subordinates. Create nodes and assign subordinates slices accordingly.

4

Print all three data structures to show hierarchy

Print the employeesArray slice on one line. Then print the linked list starting from head by traversing next pointers, printing each employee name separated by " -> ". Finally, write a recursive function printTree that takes an *EmployeeTreeNode and an indent string, prints the node's name prefixed by indent, and recursively prints subordinates with increased indentation. Call printTree(ceo, "") to print the tree hierarchy.

DSA Go

package main

import "fmt"

type EmployeeNode struct {
    name string
    next *EmployeeNode
}

type EmployeeTreeNode struct {
    name string
    subordinates []*EmployeeTreeNode
}

func main() {
    employeesArray := []string{"CEO", "Manager", "Lead", "Developer"}

    head := &EmployeeNode{name: "CEO"}
    node2 := &EmployeeNode{name: "Manager"}
    node3 := &EmployeeNode{name: "Lead"}
    node4 := &EmployeeNode{name: "Developer"}

    head.next = node2
    node2.next = node3
    node3.next = node4

    ceo := &EmployeeTreeNode{name: "CEO"}
    manager := &EmployeeTreeNode{name: "Manager"}
    lead := &EmployeeTreeNode{name: "Lead"}
    developer := &EmployeeTreeNode{name: "Developer"}

    ceo.subordinates = []*EmployeeTreeNode{manager}
    manager.subordinates = []*EmployeeTreeNode{lead}
    lead.subordinates = []*EmployeeTreeNode{developer}

    // Print all data structures
    // Your code here
}

// Add printTree function below
// Your code here

Hint

Use a loop to print the linked list with arrows. Use recursion to print the tree with indentation.