Array Reversal Techniques in DSA Java

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 first element (1) with last element (5)

[5, 2, 3, 4, 1]

Why: Swap ends to start reversing the order

Step 2: Swap second element (2) with second last element (4)

[5, 4, 3, 2, 1]

Why: Continue swapping inward to reverse the array

Step 3: Middle element (3) stays the same as it is the center

[5, 4, 3, 2, 1]

Why: No swap needed for middle element in odd length array

Result:

[5, 4, 3, 2, 1]

Annotated Code

DSA Java

public class ArrayReversal {
    public static void reverseArray(int[] arr) {
        int start = 0;
        int end = arr.length - 1;
        while (start < end) {
            int temp = arr[start]; // save start element
            arr[start] = arr[end]; // put end element at start
            arr[end] = temp; // put saved start element at end
            start++; // move start pointer forward
            end--; // move end pointer backward
        }
    }

    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        reverseArray(array);
        for (int num : array) {
            System.out.print(num + " ");
        }
    }
}

while (start < end) {

loop until pointers meet in the middle

int temp = arr[start];

save element at start to swap later

arr[start] = arr[end];

replace start element with end element

arr[end] = temp;

replace end element with saved start element

start++;

move start pointer forward to next element

end--;

move end pointer backward to next element

Output

5 4 3 2 1 

Complexity Analysis

Time: O(n) because we swap elements only once until the middle of the array

Space: O(1) because we reverse the array 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 []

No swaps happen, array remains empty

DSA Java

while (start < end) {

single element array [7]

No swaps happen, single element stays the same

DSA Java

while (start < end) {

array with duplicates [2, 2, 2]

Duplicates are swapped normally, array reversed correctly

DSA Java

while (start < end) {

When to Use This Pattern

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

Common Mistakes

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

Mistake: Swapping elements even when start equals end, causing unnecessary swap
Fix: Use condition 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 the order of elements efficiently without extra space.

The key is to swap pairs from the outside towards the center until pointers meet.

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 reversal meaning

   Reversing means flipping the order of elements so the last element comes first and the first element comes last.

2. Step 2: Compare with other options

   Sorting arranges elements by value, removing duplicates deletes repeated items, and adding elements is insertion, not reversal.

3. Final Answer:

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

4. Quick Check:

   Reversal = Flip order [OK]

Hint: Reversal flips array ends, not sorting or removing [OK]

Common Mistakes:

• Confusing reversal with sorting
• Thinking reversal removes elements
• Mixing reversal with adding elements

2. Which of the following Java code snippets correctly reverses an integer array arr in-place?

easy

A. for(int i = arr.length - 1; i >= 0; i--) { System.out.print(arr[i]); }

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

C. for(int i = 0; i < arr.length / 2; i++) { int temp = arr[i]; arr[i] = arr[arr.length - 1 - i]; arr[arr.length - 1 - i] = temp; }

D. Arrays.sort(arr);

Solution

1. Step 1: Analyze in-place reversal logic

   for(int i = 0; i < arr.length / 2; i++) { int temp = arr[i]; arr[i] = arr[arr.length - 1 - i]; arr[arr.length - 1 - i] = temp; } swaps elements from start and end moving towards center, correctly reversing the array in-place.

2. Step 2: Check other options

   for(int i = 0; i < arr.length; i++) { arr[i] = arr[arr.length - 1 - i]; } overwrites elements incorrectly, for(int i = arr.length - 1; i >= 0; i--) { System.out.print(arr[i]); } only prints reversed array without changing it, Arrays.sort(arr); sorts array, not reverses.

3. Final Answer:

   for(int i = 0; i < arr.length / 2; i++) { int temp = arr[i]; arr[i] = arr[arr.length - 1 - i]; arr[arr.length - 1 - i] = temp; } -> Option C

4. Quick Check:

   Swap pairs from ends = reversal [OK]

Hint: Swap pairs from ends up to middle for reversal [OK]

Common Mistakes:

• Overwriting elements without swapping
• Only printing reversed array without changing it
• Using sort instead of reversal

3. What will be the output of the following Java code?

int[] arr = {1, 2, 3, 4, 5};
for(int i = 0; i < arr.length / 2; i++) {
  int temp = arr[i];
  arr[i] = arr[arr.length - 1 - i];
  arr[arr.length - 1 - i] = temp;
}
for(int num : arr) {
  System.out.print(num + " ");
}

medium

A. 5 4 3 2 1

B. 1 2 3 4 5

C. 5 2 3 4 1

D. 1 4 3 2 5

Solution

1. Step 1: Trace the reversal loop

   The loop swaps arr[0] with arr[4], arr[1] with arr[3]. After swaps, array becomes [5,4,3,2,1].

2. Step 2: Print the array elements

   The print loop outputs elements in order: 5 4 3 2 1

3. Final Answer:

   5 4 3 2 1 -> Option A

4. Quick Check:

   Swapped ends = reversed array [OK]

Hint: Swapping ends reverses array; print shows reversed order [OK]

Common Mistakes:

• Not swapping correctly, leaving array unchanged
• Confusing print output with original array
• Off-by-one errors in loop

4. Identify the error in the following Java code that attempts to reverse an array arr:

for(int i = 0; i <= arr.length / 2; i++) {
  int temp = arr[i];
  arr[i] = arr[arr.length - 1 - i];
  arr[arr.length - 1 - i] = temp;
}

medium

A. The temp variable should be declared outside the loop

B. The loop condition should be 'i < arr.length / 2' to avoid swapping middle element twice

C. The swap logic is incorrect; it should swap arr[i] with arr[i+1]

D. The loop should run from 'i = arr.length - 1' down to 0

Solution

1. Step 1: Analyze loop condition

   The loop uses 'i <= arr.length / 2', which causes the middle element to be swapped twice when array length is odd.

2. Step 2: Correct loop condition

   Changing condition to 'i < arr.length / 2' ensures swaps happen only once per pair, avoiding double swap of middle element.

3. Final Answer:

   The loop condition should be 'i < arr.length / 2' to avoid swapping middle element twice -> Option B

4. Quick Check:

   Loop limit excludes middle for odd length [OK]

Hint: Use '<' not '<=' to avoid double swapping middle element [OK]

Common Mistakes:

• Using <= instead of < in loop condition
• Declaring temp outside loop unnecessarily
• Incorrect swap logic swapping wrong elements

5. Given a 2D integer array matrix of size n x n, which code snippet correctly reverses each row of the matrix in-place?

hard

A. for(int i = 0; i < n; i++) { Arrays.sort(matrix[i]); }

B. for(int i = 0; i < n; i++) { for(int j = 0; j < n; j++) { matrix[i][j] = matrix[i][n - 1 - j]; } }

C. for(int j = 0; j < n; j++) { for(int i = 0; i < n / 2; i++) { int temp = matrix[i][j]; matrix[i][j] = matrix[n - 1 - i][j]; matrix[n - 1 - i][j] = temp; } }

D. for(int i = 0; i < n; i++) { for(int j = 0; j < n / 2; j++) { int temp = matrix[i][j]; matrix[i][j] = matrix[i][n - 1 - j]; matrix[i][n - 1 - j] = temp; } }

Solution

1. Step 1: Understand reversing each row

   Reversing each row means swapping elements in each row from start to end moving towards center.

2. Step 2: Analyze options

   for(int i = 0; i < n; i++) { for(int j = 0; j < n / 2; j++) { int temp = matrix[i][j]; matrix[i][j] = matrix[i][n - 1 - j]; matrix[i][n - 1 - j] = temp; } } swaps elements in each row correctly. for(int i = 0; i < n; i++) { for(int j = 0; j < n; j++) { matrix[i][j] = matrix[i][n - 1 - j]; } } overwrites elements incorrectly. for(int j = 0; j < n; j++) { for(int i = 0; i < n / 2; i++) { int temp = matrix[i][j]; matrix[i][j] = matrix[n - 1 - i][j]; matrix[n - 1 - i][j] = temp; } } swaps columns, not rows. for(int i = 0; i < n; i++) { Arrays.sort(matrix[i]); } sorts rows, not reverses.

3. Final Answer:

   for(int i = 0; i < n; i++) { for(int j = 0; j < n / 2; j++) { int temp = matrix[i][j]; matrix[i][j] = matrix[i][n - 1 - j]; matrix[i][n - 1 - j] = temp; } } -> Option D

4. Quick Check:

   Swap pairs in each row for reversal [OK]

Hint: Reverse each row by swapping pairs from ends to center [OK]

Common Mistakes:

• Swapping columns instead of rows
• Overwriting elements without swapping
• Sorting rows instead of reversing