Array Insertion at End in DSA Go

Mental Model

An array is like a row of boxes where each box holds a value. Inserting at the end means putting a new value in the next empty box after all current values.

Analogy: Imagine a row of mailboxes where each mailbox holds a letter. Adding a letter at the end means putting it in the next empty mailbox after all the others.

Index:  [0]  [1]  [2]  [3]  [4]
Array:  5 -> 8 -> 12 -> _ -> _

Dry Run Walkthrough

Input: array: [5, 8, 12, _, _], insert value 20 at end

Goal: Add the value 20 to the first empty spot at the end of the array

Step 1: Find the first empty spot (underscore) in the array

5 -> 8 -> 12 -> _ -> _

Why: We need to know where to put the new value

Step 2: Place the value 20 in the first empty spot

5 -> 8 -> 12 -> 20 -> _

Why: This adds the new value at the end of the current values

Step 3: Update the count of elements to include the new value

5 -> 8 -> 12 -> 20 -> _

Why: So we know the array now has 4 valid elements

Result:

5 -> 8 -> 12 -> 20 -> _

Annotated Code

DSA Go

package main

import "fmt"

// Array structure with fixed size and current length
type Array struct {
	data   [5]int
	length int
}

// InsertAtEnd adds a value at the end if space is available
func (a *Array) InsertAtEnd(value int) bool {
	if a.length >= len(a.data) {
		return false // no space to insert
	}
	a.data[a.length] = value // place value at next free index
	a.length++ // increase count of elements
	return true
}

// Print prints the array elements up to current length
func (a *Array) Print() {
	for i := 0; i < a.length; i++ {
		fmt.Print(a.data[i])
		if i < a.length-1 {
			fmt.Print(" -> ")
		}
	}
	fmt.Println(" -> null")
}

func main() {
	arr := Array{data: [5]int{5, 8, 12}, length: 3}
	arr.Print() // before insertion
	inserted := arr.InsertAtEnd(20)
	if inserted {
		arr.Print() // after insertion
	} else {
		fmt.Println("Array is full, cannot insert")
	}
}

if a.length >= len(a.data) {

check if array has space for new element

a.data[a.length] = value

insert value at the next free index

a.length++

increase count of elements after insertion

Output

5 -> 8 -> 12 -> null

5 -> 8 -> 12 -> 20 -> null

Complexity Analysis

Time: O(1) because insertion at the end is a direct assignment without loops

Space: O(1) because no extra space is needed beyond the fixed array

vs Alternative: Compared to inserting at the start or middle which may require shifting elements (O(n)), insertion at end is faster and simpler

Edge Cases

Array is full (length equals capacity)

Insertion fails and returns false

DSA Go

if a.length >= len(a.data) {

Array is empty (length zero)

Insertion places value at index 0 successfully

DSA Go

a.data[a.length] = value

When to Use This Pattern

When you need to add data to a collection quickly and order doesn't require shifting, use array insertion at end for O(1) speed.

Common Mistakes

Mistake: Trying to insert without checking if array is full, causing overwrite or error
Fix: Always check if current length is less than array capacity before inserting

Summary

Adds a new value to the next free position at the end of an array.

Use when you want to append data quickly without rearranging existing elements.

The key is to track the current number of elements to know where to insert next.

Practice

1. What happens when you insert an element at the end of a fixed-size array in Go?

easy

A. You cannot insert because arrays have fixed size

B. The element replaces the first element

C. The element is added and array size increases automatically

D. The array is converted to a slice automatically

Solution

1. Step 1: Understand Go array size

   Arrays in Go have a fixed size defined at declaration and cannot grow.

2. Step 2: Effect of insertion at end

   Since size is fixed, you cannot add new elements beyond the declared size.

3. Final Answer:

   You cannot insert because arrays have fixed size -> Option A

4. Quick Check:

   Fixed size array = no insertion beyond size [OK]

Hint: Arrays have fixed size; no automatic growth on insertion [OK]

Common Mistakes:

• Thinking arrays can grow automatically
• Confusing arrays with slices
• Assuming insertion replaces last element

2. Which of the following is the correct way to append an element 10 to a slice named nums in Go?

easy

A. nums = nums + 10

B. nums.append(10)

C. append(nums, 10)

D. nums = append(nums, 10)

Solution

1. Step 1: Recall Go slice append syntax

   In Go, append returns a new slice with the element added, so assignment is needed.

2. Step 2: Check each option

   nums = append(nums, 10) correctly assigns the result of append to nums. Others are invalid syntax or missing assignment.

3. Final Answer:

   nums = append(nums, 10) -> Option D

4. Quick Check:

   Use append with assignment to add element [OK]

Hint: Always assign append result back to slice variable [OK]

Common Mistakes:

• Not assigning append result back
• Using method call syntax like nums.append()
• Trying to add with + operator

3. What is the output of the following Go code?

nums := []int{1, 2, 3}
nums = append(nums, 4)
fmt.Println(nums)

medium

A. [1 2 3]

B. [4 1 2 3]

C. [1 2 3 4]

D. Compilation error

Solution

1. Step 1: Understand initial slice and append

   nums starts as [1 2 3]. append(nums, 4) adds 4 at the end.

2. Step 2: Print the updated slice

   After append, nums becomes [1 2 3 4], which is printed.

3. Final Answer:

   [1 2 3 4] -> Option C

4. Quick Check:

   Appending 4 adds it at end [OK]

Hint: append adds element at end, print shows updated slice [OK]

Common Mistakes:

• Expecting original slice without new element
• Thinking append adds at start
• Confusing slice with array syntax

4. Identify the error in the following Go code that tries to insert 5 at the end of an array:

arr := [3]int{1, 2, 3}
arr = append(arr, 5)
fmt.Println(arr)

medium

A. Cannot use append on array; append works only on slices

B. Array size is too small; must declare larger array

C. Missing import for fmt package

D. Syntax error in array declaration

Solution

1. Step 1: Check type of arr

   arr is declared as an array [3]int, which has fixed size and no append method.

2. Step 2: Understand append usage

   append works only on slices, not arrays. Using append on array causes error.

3. Final Answer:

   Cannot use append on array; append works only on slices -> Option A

4. Quick Check:

   append requires slice, not array [OK]

Hint: append works only on slices, not fixed-size arrays [OK]

Common Mistakes:

• Trying to append to fixed-size array
• Ignoring difference between array and slice
• Assuming append auto-converts array to slice

5. Given a slice data := []int{2, 4, 6}, which code snippet correctly inserts the value 8 at the end and then doubles all elements?

hard

A. data = append(data, 8)
for _, v := range data {
v *= 2
}
fmt.Println(data)

B. data = append(data, 8)
for i := range data {
data[i] *= 2
}
fmt.Println(data)

C. data = append(data, 8)
for i := 0; i < len(data); i++ {
data[i] = data[i] + 2
}
fmt.Println(data)

D. data = append(data, 8)
for i := range data {
data[i] = data[i] / 2
}
fmt.Println(data)

Solution

1. Step 1: Append 8 to slice

   data = append(data, 8) adds 8 at the end, making data [2 4 6 8].

2. Step 2: Double each element correctly

   Using for i := range data and data[i] *= 2 doubles each element in place.

3. Step 3: Check other options

   data = append(data, 8) for _, v := range data { v *= 2 } fmt.Println(data) doubles copy of value, not original slice. Options C and D do wrong math.

4. Final Answer:

   data = append(data, 8) for i := range data { data[i] *= 2 } fmt.Println(data) -> Option B

5. Quick Check:

   Append then modify elements by index [OK]

Hint: Modify slice elements by index, not by value copy [OK]

Common Mistakes:

• Modifying value copy in range instead of slice element
• Using wrong arithmetic operation
• Not assigning append result back