Array Reversal Techniques in DSA Go

Mental Model

Reversing an array means flipping its order so the last element becomes first and the first becomes last.

Analogy: Imagine a row of books on a shelf. Reversing the array is like taking the books from both ends and swapping them until you meet in the middle.

[1] -> [2] -> [3] -> [4] -> [5] -> null
 ↑start          ↑end

Dry Run Walkthrough

Input: array: [1, 2, 3, 4, 5]

Goal: Reverse the array so it becomes [5, 4, 3, 2, 1]

Step 1: swap elements at start=0 and end=4

[5, 2, 3, 4, 1]

Why: Swap first and last to start reversing

Step 2: move start to 1 and end to 3

[5, 2, 3, 4, 1] ↑start      ↑end

Why: Move inward to swap next pair

Step 3: swap elements at start=1 and end=3

[5, 4, 3, 2, 1]

Why: Swap second and second last elements

Step 4: move start to 2 and end to 2

[5, 4, 3, 2, 1]    ↑start/end

Why: Pointers meet in the middle, reversal done

Result:

[5, 4, 3, 2, 1]

Annotated Code

DSA Go

package main

import "fmt"

func reverseArray(arr []int) {
    start, end := 0, len(arr)-1
    for start < end {
        arr[start], arr[end] = arr[end], arr[start] // swap elements
        start++ // move start pointer inward
        end--   // move end pointer inward
    }
}

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

arr[start], arr[end] = arr[end], arr[start] // swap elements

swap elements at start and end to reverse order

start++ // move start pointer inward

advance start pointer to next element

end-- // move end pointer inward

move end pointer backward to next element

Output

[5 4 3 2 1]

Complexity Analysis

Time: O(n) because we swap pairs moving inward until the middle, touching each element once

Space: O(1) because reversal is done in place without extra storage

vs Alternative: Compared to creating a new reversed array which uses O(n) extra space, this method is more space efficient

Edge Cases

empty array []

function returns immediately with no changes

DSA Go

for start < end {

array with one element [7]

no swaps happen, array remains the same

DSA Go

for start < end {

array with duplicate elements [2, 2, 2]

duplicates are swapped but array looks the same after reversal

DSA Go

arr[start], arr[end] = arr[end], arr[start]

When to Use This Pattern

When you need to reverse the order of elements in a list or array efficiently, use the two-pointer swap pattern to reverse in place.

Common Mistakes

Mistake: Swapping elements without moving pointers inward, causing infinite loop
Fix: Increment start and decrement end pointers inside the loop after swapping

Mistake: Using <= instead of < in loop condition, causing unnecessary swap of middle element
Fix: Use start < end to stop before pointers meet or cross

Summary

Reverses an array by swapping elements from both ends moving inward.

Use when you want to reverse an array efficiently without extra space.

The key is to swap pairs from start and end pointers moving towards the center.

Practice

1. What does reversing an array mean in simple terms?

easy

A. Changing the order of elements so the last becomes first and first becomes last

B. Sorting the array in ascending order

C. Removing duplicate elements from the array

D. Adding new elements at the end of the array

Solution

1. Step 1: Understand array order

   An array has elements arranged in a sequence from first to last.

2. Step 2: Define reversal

   Reversing means flipping this order so the last element comes first and the first goes last.

3. Final Answer:

   Changing the order of elements so the last becomes first and first becomes last -> Option A

4. Quick Check:

   Reverse = Flip order [OK]

Hint: Reverse means flip the order of elements [OK]

Common Mistakes:

• Confusing reversal with sorting
• Thinking reversal removes elements
• Believing reversal adds elements

2. Which of the following Go code snippets correctly reverses an array named arr of integers?

easy

A. for i := len(arr)-1; i >= 0; i-- { arr[i] = arr[i] }

B. for i := 0; i < len(arr); i++ { arr[i] = arr[len(arr)-1-i] }

C. for i := 0; i < len(arr)/2; i++ { arr[i], arr[len(arr)-1-i] = arr[len(arr)-1-i], arr[i] }

D. for i := 0; i < len(arr); i++ { arr[i] = arr[i+1] }

Solution

1. Step 1: Identify correct swapping logic

   for i := 0; i < len(arr)/2; i++ { arr[i], arr[len(arr)-1-i] = arr[len(arr)-1-i], arr[i] } swaps elements from start and end moving towards the center, which is the correct reversal method.

2. Step 2: Check other options for errors

   for i := 0; i < len(arr); i++ { arr[i] = arr[len(arr)-1-i] } overwrites elements without swapping, losing data. for i := 0; i < len(arr); i++ { arr[i] = arr[i+1] } shifts elements incorrectly. for i := len(arr)-1; i >= 0; i-- { arr[i] = arr[i] } does nothing effective.

3. Final Answer:

   for i := 0; i < len(arr)/2; i++ { arr[i], arr[len(arr)-1-i] = arr[len(arr)-1-i], arr[i] } -> Option C

4. Quick Check:

   Swap pairs from ends to center = for i := 0; i < len(arr)/2; i++ { arr[i], arr[len(arr)-1-i] = arr[len(arr)-1-i], arr[i] } [OK]

Hint: Swap pairs from start and end until middle [OK]

Common Mistakes:

• Not swapping but overwriting elements
• Looping over full array instead of half
• Ignoring index bounds causing errors

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

arr := []int{1, 2, 3, 4, 5}
for i := 0; i < len(arr)/2; i++ {
    arr[i], arr[len(arr)-1-i] = arr[len(arr)-1-i], arr[i]
}
fmt.Println(arr)

medium

A. [5 4 3 2 1]

B. [1 2 3 4 5]

C. [5 2 3 4 1]

D. [1 5 3 2 4]

Solution

1. Step 1: Trace swaps in loop

   Loop runs i=0 and i=1 (since len=5, half=2). - i=0: swap arr[0] and arr[4] -> arr becomes [5 2 3 4 1] - i=1: swap arr[1] and arr[3] -> arr becomes [5 4 3 2 1]

2. Step 2: Check final array after loop

   After both swaps, array is [5 4 3 2 1]. But the code prints after loop, so output is [5 4 3 2 1].

3. Final Answer:

   [5 4 3 2 1] -> Option A

4. Quick Check:

   Swapped ends inward = reversed array [OK]

Hint: Swap pairs from ends, middle stays same if odd length [OK]

Common Mistakes:

• Only swapping first and last once
• Not swapping pairs correctly
• Confusing output with original array

4. Find the error in this Go code that tries to reverse an array arr:

for i := 0; i <= len(arr)/2; i++ {
    arr[i] = arr[len(arr)-1-i]
}

medium

A. The loop should run only till i < len(arr)/2, not <=

B. It overwrites elements without swapping, losing data

C. The code swaps elements correctly, no error

D. The index len(arr)-1-i is out of range

Solution

1. Step 1: Analyze loop and assignment

   The code assigns arr[i] = arr[len(arr)-1-i] without swapping, so original arr[i] is lost.

2. Step 2: Understand consequence

   Without swapping, the array is partially overwritten and not reversed correctly.

3. Final Answer:

   It overwrites elements without swapping, losing data -> Option B

4. Quick Check:

   Overwrite without swap loses data [OK]

Hint: Always swap pairs, don't overwrite [OK]

Common Mistakes:

• Using <= instead of < in loop
• Not swapping both elements
• Ignoring data loss from overwrite

5. Given a slice arr := []int{1, 2, 3, 4, 5, 6}, write a Go function that reverses the slice in place and returns it. Which of the following is the correct implementation?

hard

A. func reverse(arr []int) []int {
for i := 0; i < len(arr); i++ {
arr[i] = arr[len(arr)-1-i]
}
return arr
}

B. func reverse(arr []int) []int {
for i := 0; i <= len(arr)/2; i++ {
arr[i] = arr[len(arr)-1-i]
}
return arr
}

C. func reverse(arr []int) []int {
for i := len(arr)-1; i >= 0; i-- {
arr[i] = arr[i]
}
return arr
}

D. func reverse(arr []int) []int {
for i := 0; i < len(arr)/2; i++ {
arr[i], arr[len(arr)-1-i] = arr[len(arr)-1-i], arr[i]
}
return arr
}

Solution

1. Step 1: Check correct swapping logic

   func reverse(arr []int) []int { for i := 0; i < len(arr)/2; i++ { arr[i], arr[len(arr)-1-i] = arr[len(arr)-1-i], arr[i] } return arr } swaps elements from start and end moving inward, correctly reversing the slice in place.

2. Step 2: Verify other options

   func reverse(arr []int) []int { for i := 0; i < len(arr); i++ { arr[i] = arr[len(arr)-1-i] } return arr } overwrites without swapping, losing data. func reverse(arr []int) []int { for i := len(arr)-1; i >= 0; i-- { arr[i] = arr[i] } return arr } does nothing effective. func reverse(arr []int) []int { for i := 0; i <= len(arr)/2; i++ { arr[i] = arr[len(arr)-1-i] } return arr } overwrites without swapping and uses <= causing index issues.

3. Final Answer:

   func reverse(arr []int) []int { for i := 0; i < len(arr)/2; i++ { arr[i], arr[len(arr)-1-i] = arr[len(arr)-1-i], arr[i] } return arr } -> Option D

4. Quick Check:

   Swap pairs from ends to center and return [OK]

Hint: Swap pairs up to half length, then return [OK]

Common Mistakes:

• Overwriting elements without swapping
• Looping beyond half length
• Not returning the modified slice