Array Reversal Techniques in DSA C - Build from Scratch

Array Reversal Techniques

📖 Scenario: You are working on a simple program that helps reverse the order of numbers in an array. This is like taking a row of books on a shelf and flipping their order so the last book becomes the first and the first becomes the last.

🎯 Goal: Build a C program that creates an array of numbers, sets up a helper variable for swapping, reverses the array using a loop, and then prints the reversed array.

📋 What You'll Learn

Create an integer array called numbers with these exact values: 10, 20, 30, 40, 50

Create an integer variable called temp to help with swapping values

Use a for loop with an integer variable i to reverse the array in place

Print the reversed array elements separated by spaces on one line

💡 Why This Matters

🌍 Real World

Reversing arrays is useful in many situations like undoing actions, reversing order of tasks, or processing data backwards.

💼 Career

Understanding array manipulation and loops is fundamental for programming jobs, especially in embedded systems, game development, and software engineering.

1

Create the array

Create an integer array called numbers with these exact values: 10, 20, 30, 40, 50

DSA C

# Create the array called numbers with values 10, 20, 30, 40, 50
// Your code here

Hint

Use the syntax int arrayName[size] = {values}; to create the array.

2

Add a helper variable for swapping

Create an integer variable called temp to help with swapping values

DSA C

int numbers[5] = {10, 20, 30, 40, 50};
// Create an integer variable called temp
// Your code here

Hint

Declare temp as an integer variable without initializing it.

3

Reverse the array using a loop

Use a for loop with an integer variable i to reverse the array numbers in place by swapping elements. Loop from i = 0 to i < 2 and swap numbers[i] with numbers[4 - i] using temp

DSA C

int numbers[5] = {10, 20, 30, 40, 50};
int temp;
// Reverse the array using a for loop and temp
// Your code here

Hint

Swap the elements at positions i and 4 - i inside the loop using temp.

4

Print the reversed array

Use a for loop with an integer variable i from 0 to 4 to print each element of the reversed numbers array separated by spaces on one line

DSA C

int numbers[5] = {10, 20, 30, 40, 50};
int temp;
for (int i = 0; i < 2; i++) {
    temp = numbers[i];
    numbers[i] = numbers[4 - i];
    numbers[4 - i] = temp;
}
// Print the reversed array elements separated by spaces
// Your code here

Hint

Use printf inside the loop to print each number followed by a space except after the last number.

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 from first to last index.

2. Step 2: Define reversal

   Reversing means swapping elements so the last element moves to the first position and vice versa.

3. Final Answer:

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

4. Quick Check:

   Reversal = Reverse order [OK]

Hint: Reversal flips the array order front to back [OK]

Common Mistakes:

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

2. Which of the following C code snippets correctly swaps two elements arr[i] and arr[j] for array reversal?

easy

A. arr[i] = arr[j]; arr[j] = arr[i];

B. temp = arr[j]; arr[j] = arr[i]; arr[i] = temp;

C. int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp;

D. arr[i] = arr[j]; arr[j] = temp;

Solution

1. Step 1: Use a temporary variable for swapping

   To swap two values, store one in a temporary variable to avoid overwriting.

2. Step 2: Assign values correctly

   Assign arr[i] to temp, then arr[j] to arr[i], then temp to arr[j].

3. Final Answer:

   int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; -> Option C

4. Quick Check:

   Swap uses temp variable [OK]

Hint: Always use a temp variable to swap two elements safely [OK]

Common Mistakes:

• Overwriting one element before saving it
• Using uninitialized temp variable
• Swapping without temp causes data loss

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

int arr[] = {1, 2, 3, 4, 5};
int n = 5;
for(int i = 0; i < n/2; i++) {
  int temp = arr[i];
  arr[i] = arr[n - i - 1];
  arr[n - i - 1] = temp;
}
for(int i = 0; i < n; i++) {
  printf("%d ", arr[i]);
}

medium

A. 2 1 4 3 5

B. 5 4 3 2 1

C. 1 2 3 4 5

D. 5 3 2 4 1

Solution

1. Step 1: Understand the loop swaps

   The loop swaps elements from start and end moving towards the center: arr[0] with arr[4], arr[1] with arr[3].

2. Step 2: Trace swaps

   Swap 1 and 5 -> arr = {5, 2, 3, 4, 1}; Swap 2 and 4 -> arr = {5, 4, 3, 2, 1}; middle element 3 stays same.

3. Final Answer:

   5 4 3 2 1 -> Option B

4. Quick Check:

   Reversed array = 5 4 3 2 1 [OK]

Hint: Swapping pairs from ends reverses array [OK]

Common Mistakes:

• Not swapping all pairs correctly
• Loop running too many or too few times
• Confusing indices in swap

4. Identify the error in this C code snippet intended to reverse an array:

int arr[] = {10, 20, 30, 40};
int n = 4;
for(int i = 0; i <= n/2; i++) {
  int temp = arr[i];
  arr[i] = arr[n - i - 1];
  arr[n - i - 1] = temp;
}

medium

A. Temporary variable temp is not declared

B. The swap logic is incorrect

C. Array size n is wrong

D. The loop condition should be i < n/2 instead of i <= n/2

Solution

1. Step 1: Analyze loop condition

   The loop runs from i = 0 to i <= n/2, which means it runs one extra iteration when i = n/2.

2. Step 2: Understand effect of extra iteration

   For even n=4, n/2=2, so i=2 is invalid index for swapping (out of bounds or swaps middle element twice).

3. Final Answer:

   The loop condition should be i < n/2 instead of i <= n/2 -> Option D

4. Quick Check:

   Loop runs too far, fix condition [OK]

Hint: Use i < n/2 to avoid extra swap [OK]

Common Mistakes:

• Using <= causes out-of-bound swaps
• Confusing array length with index
• Ignoring zero-based indexing

5. Given an array arr of size n, which approach is best to reverse the array in-place with minimum extra memory and why?

hard

A. Use two pointers, one at start and one at end, swap and move towards center

B. Create a new array and copy elements from end to start

C. Use recursion to swap elements from ends

D. Sort the array in descending order

Solution

1. Step 1: Compare memory usage of methods

   Creating a new array uses extra memory equal to array size; recursion uses call stack memory.

2. Step 2: Evaluate two-pointer method

   Two pointers swap elements in-place without extra memory, making it efficient and simple.

3. Final Answer:

   Use two pointers, one at start and one at end, swap and move towards center -> Option A

4. Quick Check:

   Two-pointer swap = minimal memory [OK]

Hint: Two-pointer swap reverses in-place with no extra memory [OK]

Common Mistakes:

• Using extra arrays wastes memory
• Recursion adds unnecessary stack overhead
• Sorting does not reverse original order