Array Reversal Techniques in DSA Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind reversing an array?

Reversing an array means changing the order of elements so that the first element becomes the last, the second becomes the second last, and so on, effectively flipping the array.

beginner

How does the two-pointer technique work for array reversal?

Two pointers start at the beginning and end of the array. They swap elements and move towards the center until they meet or cross, reversing the array in place.

intermediate

What is a key advantage of reversing an array in place?

Reversing in place uses no extra space, so it is memory efficient and faster since it avoids creating a new array.

beginner

Show the dry run steps for reversing [1, 2, 3, 4, 5] using two pointers.

Step 1: Swap elements at positions 0 and 4 → [5, 2, 3, 4, 1]
Step 2: Swap elements at positions 1 and 3 → [5, 4, 3, 2, 1]
Step 3: Pointers meet at position 2, stop.
Final reversed array: [5, 4, 3, 2, 1]

beginner

What is a simple alternative method to reverse an array using extra space?

Create a new array and copy elements from the original array starting from the last element to the first, then replace or use the new array.

Which technique reverses an array without using extra space?

A Creating a new reversed array

B Using recursion with extra array

C Two-pointer swapping

D Sorting the array in descending order

Two-pointer swapping reverses the array in place without extra space.

What happens when the two pointers meet or cross during array reversal?

A The reversal process stops

B The array is partially reversed

C Pointers reset to start

D Elements are swapped again

When pointers meet or cross, the array is fully reversed and the process stops.

Which of these is NOT a benefit of in-place array reversal?

A Original array remains unchanged

B Faster execution

C No extra memory used

D Simple implementation

In-place reversal changes the original array; it does not keep it unchanged.

What is the time complexity of reversing an array using two pointers?

A O(1)

B O(n^2)

C O(log n)

D O(n)

Each element is visited once, so time complexity is O(n).

If an array has 6 elements, how many swaps are needed to reverse it using two pointers?

A 6

B 3

C 2

D 5

Swaps needed are half the number of elements, so 6/2 = 3.

Explain how to reverse an array using the two-pointer technique step-by-step.

Think about swapping first and last elements, then moving towards the center.

Describe the difference between reversing an array in place and using extra space.

Consider memory and whether the original array changes.

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