Arrays vs Other Data Structures When to Choose Arrays in DSA Go - Trade-offs & Analysis

Mental Model

Arrays store items in order, side by side, so you can quickly find any item by its position.

Analogy: Think of an egg carton where each egg has its own spot. You can grab the 3rd egg quickly because you know exactly where it sits.

[0] -> 5 -> [1] -> 8 -> [2] -> 3 -> [3] -> 7 -> null

Dry Run Walkthrough

Input: array: [5, 8, 3, 7], find value at index 2, add value 10 at end

Goal: Show how arrays let us quickly get by position and add at the end

Step 1: Access value at index 2

[0] -> 5 -> [1] -> 8 -> [2↑] -> 3 -> [3] -> 7 -> null

Why: We want the value at position 2, which is 3

Step 2: Add value 10 at the end

[0] -> 5 -> [1] -> 8 -> [2] -> 3 -> [3] -> 7 -> [4↑] -> 10 -> null

Why: Arrays store items next to each other, so adding at the end is simple

Result:

[0] -> 5 -> [1] -> 8 -> [2] -> 3 -> [3] -> 7 -> [4] -> 10 -> null
Value at index 2 is 3

Annotated Code

DSA Go

package main

import "fmt"

func main() {
	arr := []int{5, 8, 3, 7}

	// Access value at index 2
	value := arr[2] // direct access by index

	// Add value 10 at the end
	arr = append(arr, 10) // add new item at the end

	// Print array
	for i, v := range arr {
		fmt.Printf("[%d] -> %d -> ", i, v)
	}
	fmt.Println("null")

	// Print accessed value
	fmt.Printf("Value at index 2 is %d\n", value)
}

value := arr[2] // direct access by index

Access element directly by position for fast retrieval

arr = append(arr, 10) // add new item at the end

Add new element at the end efficiently

Output

[0] -> 5 -> [1] -> 8 -> [2] -> 3 -> [3] -> 7 -> [4] -> 10 -> null

Value at index 2 is 3

Complexity Analysis

Time: O(1) for access because arrays allow direct position lookup; O(1) amortized for adding at end due to append operation

Space: O(n) because arrays store all elements in contiguous memory

vs Alternative: Compared to linked lists, arrays provide faster access by index but slower insertions/deletions in the middle

Edge Cases

empty array

Accessing any index causes error; adding at end creates first element

DSA Go

arr = append(arr, 10) // add new item at the end

single element array

Access index 0 returns the element; append adds new element at index 1

DSA Go

value := arr[0] // direct access by index

When to Use This Pattern

When you need fast access to elements by position and mostly add at the end, arrays are the best choice because they store data contiguously.

Common Mistakes

Mistake: Trying to insert or delete elements in the middle of an array without considering the cost
Fix: Remember arrays require shifting elements for middle insertions/deletions, so use linked lists if frequent middle changes are needed

Summary

Arrays store elements in order and allow fast access by position.

Use arrays when you need quick access by index and mostly add elements at the end.

The key insight is that arrays keep data side by side, making position-based access very fast.

Practice

1. Which of the following is the best reason to choose an array over other data structures like linked lists or hash maps?

easy

A. When you want a flexible size that grows automatically

B. When you need to frequently insert or delete elements in the middle

C. When you want to store key-value pairs

D. When you need fast access to elements by index

Solution

1. Step 1: Understand array access speed

   Arrays allow direct access to elements using their index, which is very fast (constant time).

2. Step 2: Compare with other data structures

   Linked lists are slower for access by index, hash maps store key-value pairs, and dynamic structures grow automatically but may have overhead.

3. Final Answer:

   When you need fast access to elements by index -> Option D

4. Quick Check:

   Fast index access = Array = A [OK]

Hint: Arrays give quick access by position, unlike others [OK]

Common Mistakes:

• Choosing arrays for frequent insertions/deletions
• Confusing arrays with key-value stores
• Assuming arrays grow automatically

2. Which of the following is the correct way to declare an array of 5 integers in Go?

easy

A. var arr [5]int

B. arr := []int{5}

C. var arr = make([]int, 5)

D. arr := [5]int

Solution

1. Step 1: Recall Go array declaration syntax

   Arrays in Go are declared with fixed size using syntax: var name [size]type.

2. Step 2: Analyze options

   var arr [5]int uses correct syntax for fixed-size array. arr := []int{5} is a slice literal with one element 5. var arr = make([]int, 5) creates a slice with length 5, not an array. arr := [5]int is invalid syntax.

3. Final Answer:

   var arr [5]int -> Option A

4. Quick Check:

   Fixed size array = var arr [5]int [OK]

Hint: Fixed size arrays use var name [size]type in Go [OK]

Common Mistakes:

• Using slice syntax instead of array syntax
• Confusing make() with array creation
• Incorrect literal syntax for arrays

3. What will be the output of the following Go code snippet?

package main
import "fmt"
func main() {
    arr := [3]int{10, 20, 30}
    fmt.Println(arr[1])
}

medium

A. 10

B. 20

C. 30

D. Index out of range error

Solution

1. Step 1: Identify array elements and indexing

   The array has elements [10, 20, 30] at indices 0, 1, and 2 respectively.

2. Step 2: Access element at index 1

   arr[1] refers to the second element, which is 20.

3. Final Answer:

   20 -> Option B

4. Quick Check:

   arr[1] = 20 [OK]

Hint: Remember arrays start at index 0 in Go [OK]

Common Mistakes:

• Confusing index 1 with first element
• Expecting runtime error for valid index
• Misreading array initialization

4. Consider the following Go code snippet. What is the error and how to fix it?

package main
import "fmt"
func main() {
    arr := [3]int{1, 2, 3}
    arr[3] = 4
    fmt.Println(arr)
}

medium

A. Index out of range error; fix by using valid index 0 to 2

B. Syntax error; fix by declaring arr as slice

C. No error, output: [1 2 3 4]

D. Compile error; fix by increasing array size to 4

Solution

1. Step 1: Identify the invalid index access

   Array size is 3, valid indices are 0, 1, 2. Accessing arr[3] is out of range.

2. Step 2: Fix the error

   Use indices within 0 to 2 or declare a larger array if needed.

3. Final Answer:

   Index out of range error; fix by using valid index 0 to 2 -> Option A

4. Quick Check:

   Array index must be within size [OK]

Hint: Array indices go from 0 to size-1 only [OK]

Common Mistakes:

• Trying to assign outside array bounds
• Confusing array size with slice length
• Ignoring runtime panic from invalid index

5. You need to store a fixed number of sensor readings that will not change in size and require fast access by position. Which data structure should you choose and why?

medium

A. Use a linked list because it allows easy insertion and deletion

B. Use a hash map because it provides key-value access

C. Use an array because it has fixed size and fast index access

D. Use a slice because it automatically resizes

Solution

1. Step 1: Analyze requirements

   The size is fixed and will not change, and fast access by position is needed.

2. Step 2: Match data structure properties

   Arrays have fixed size and provide constant time access by index. Linked lists are slower for access, hash maps are for key-value pairs, slices resize dynamically which is unnecessary here.

3. Final Answer:

   Use an array because it has fixed size and fast index access -> Option C

4. Quick Check:

   Fixed size + fast access = Array = D [OK]

Hint: Fixed size and fast access? Choose array [OK]

Common Mistakes:

• Choosing linked list for fixed size data
• Using hash map without key-value need
• Picking slice when resizing is not required