Why Trees Exist and What Linked Lists and Arrays Cannot Do in DSA Rust - Performance Analysis

Time Complexity: Why Trees Exist and What Linked Lists and Arrays Cannot Do

O(n) for array and linked list, O(log n) for balanced binary tree

Understanding Time Complexity

We want to understand why trees are useful by looking at what linked lists and arrays struggle with.

What question are we trying to answer? How does the time to find or organize data change with these structures?

Scenario Under Consideration

Analyze the time complexity of searching for a value in an array, a linked list, and a binary tree.

// Search in array
fn search_array(arr: &[i32], target: i32) -> bool {
    for &item in arr {
        if item == target {
            return true;
        }
    }
    false
}

// Search in linked list
struct Node {
    value: i32,
    next: Option>,
}

fn search_list(head: &Option>, target: i32) -> bool {
    let mut current = head;
    while let Some(node) = current {
        if node.value == target {
            return true;
        }
        current = &node.next;
    }
    false
}

// Search in binary tree
struct TreeNode {
    value: i32,
    left: Option>,
    right: Option>,
}

fn search_tree(root: &Option>, target: i32) -> bool {
    if let Some(node) = root {
        if node.value == target {
            return true;
        } else if target < node.value {
            return search_tree(&node.left, target);
        } else {
            return search_tree(&node.right, target);
        }
    }
    false
}
    

This code shows how searching works in arrays, linked lists, and binary trees.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Checking each element one by one in array and list; recursive steps down tree branches.
• How many times: Up to n times for array and list; up to height of tree (log n for balanced tree) for tree search.

How Execution Grows With Input

As input size grows, array and list searches check more items one by one, but tree search checks fewer steps if balanced.

Input Size (n)	Approx. Operations Array/List	Approx. Operations Tree
10	10	~4
100	100	~7
1000	1000	~10

Pattern observation: Array and list grow linearly; tree grows slowly with input size if balanced.

Final Time Complexity

Time Complexity: O(n) for array and linked list search; O(log n) for balanced binary tree search

This means trees can find items faster than arrays or lists as data grows large, if the tree stays balanced.

Common Mistake

[X] Wrong: "Trees always search faster than arrays or lists no matter what."

[OK] Correct: If the tree is not balanced, search can degrade to checking many nodes like a list, losing speed advantage.

Interview Connect

Understanding why trees exist helps you explain data choices clearly and shows you know how to handle large data efficiently.

Self-Check

"What if the binary tree is not balanced? How would the time complexity of search change compared to a balanced tree?"

Practice

1. Why do trees exist as a data structure when we already have arrays and linked lists?

easy

A. Because trees allow hierarchical data representation which arrays and linked lists cannot efficiently provide

B. Because trees use less memory than arrays and linked lists

C. Because trees are easier to implement than arrays and linked lists

D. Because trees always have faster access time than arrays

Solution

1. Step 1: Understand the limitation of arrays and linked lists

   Arrays and linked lists store data linearly, which makes representing hierarchical relationships difficult and inefficient.

2. Step 2: Identify the advantage of trees

   Trees naturally represent hierarchical data with parent-child relationships, enabling efficient searching and organization of such data.

3. Final Answer:

   Trees allow hierarchical data representation which arrays and linked lists cannot efficiently provide -> Option A

4. Quick Check:

   Hierarchical data needs trees [OK]

Hint: Trees represent hierarchy; arrays and lists are linear [OK]

Common Mistakes:

• Thinking trees always use less memory
• Assuming trees are simpler to implement
• Believing trees always have faster access than arrays

2. Which of the following is the correct way to define a simple binary tree node struct in Rust?

easy

A. struct Node { value: i32, left: Option, right: Option }

B. struct Node { value: i32, left: Node, right: Node }

C. struct Node { value: i32, left: &Node, right: &Node }

D. struct Node { value: i32, left: Box<Node>, right: Box<Node> }

Solution

1. Step 1: Understand Rust ownership and recursive types

   Recursive types like trees need indirection (Box) and optional to allow empty children.

2. Step 2: Check each option

   struct Node { value: i32, left: Option, right: Option } uses Option for left and right, which is correct. struct Node { value: i32, left: Node, right: Node } is invalid because it causes infinite size. struct Node { value: i32, left: &Node, right: &Node } uses references without lifetimes. struct Node { value: i32, left: Box<Node>, right: Box<Node> } lacks Option, so no empty child allowed.

3. Final Answer:

   struct Node { value: i32, left: Option, right: Option } -> Option A

4. Quick Check:

   Recursive structs need Option [OK]

Hint: Use Option for recursive tree nodes in Rust [OK]

Common Mistakes:

• Defining child nodes without Box causing infinite size
• Using references without lifetimes
• Not using Option for nullable children

3. What will be the output of the following Rust code that builds a simple binary tree and prints the root value?

struct Node {
    value: i32,
    left: Option,
    right: Option,
}

fn main() {
    let root = Node {
        value: 10,
        left: Some(Box::new(Node { value: 5, left: None, right: None })),
        right: Some(Box::new(Node { value: 15, left: None, right: None })),
    };
    println!("{}", root.value);
}

medium

A. 15

B. 5

C. 10

D. Compilation error

Solution

1. Step 1: Analyze the tree construction

   The root node is created with value 10, left child 5, right child 15.

2. Step 2: Check the printed value

   The code prints root.value, which is 10.

3. Final Answer:

   10 -> Option C

4. Quick Check:

   Print root.value = 10 [OK]

Hint: Print root.value to get 10 [OK]

Common Mistakes:

• Confusing child values with root value
• Expecting print of left or right child
• Assuming compilation error due to Option usage

4. The following Rust code tries to create a binary tree node but fails to compile. What is the error?

struct Node {
    value: i32,
    left: Box<Node>,
    right: Box<Node>,
}

fn main() {
    let root = Node {
        value: 1,
        left: Box::new(Node { value: 2, left: Box::new(Node { value: 3, left: None, right: None }), right: None }),
        right: Box::new(Node { value: 4, left: None, right: None }),
    };
}

medium

A. Cannot use None for Box<Node> fields; should use Option

B. Missing semicolon after struct definition

C. Box cannot be used inside structs

D. Cannot create nested structs in Rust

Solution

1. Step 1: Identify the field types and assigned values

   The struct fields left and right are Box<Node>, but code assigns None to some of them.

2. Step 2: Understand why None is invalid here

   None is an Option variant, but fields are Box<Node> (non-optional), so None cannot be assigned.

3. Final Answer:

   Cannot use None for Box<Node> fields; should use Option -> Option B

4. Quick Check:

   Use Option for nullable children [OK]

Hint: Use Option to allow None children [OK]

Common Mistakes:

• Thinking Box<Node> can be None
• Ignoring Option wrapper for nullable fields
• Assuming Box is not allowed in structs

5. Given that arrays and linked lists store data linearly, which of the following real-world problems is best solved using a tree data structure instead?

medium

A. Storing a list of daily temperatures in order

B. Maintaining a queue of customers waiting in line

C. Storing a sequence of characters in a string

D. Representing a company's organizational chart with managers and employees

Solution

1. Step 1: Analyze each problem type

   Options A, B, and D represent linear data best suited for arrays or linked lists.

2. Step 2: Identify hierarchical data

   Representing a company's organizational chart with managers and employees describes an organizational chart, which is hierarchical and fits tree structures.

3. Final Answer:

   Representing a company's organizational chart with managers and employees -> Option D

4. Quick Check:

   Hierarchical data needs trees [OK]

Hint: Use trees for hierarchical data like org charts [OK]

Common Mistakes:

• Choosing linear data problems for trees
• Confusing queues or sequences with trees
• Ignoring data relationships