We create a new array and copy elements from the original array into it in reverse order. Finally, we overwrite the original array with the reversed one. This is straightforward but uses extra space.

Create a new array of the same size as the original.
Traverse the original array from the last element to the first.
Copy each element into the new array starting from index 0.
Copy back the reversed array into the original array.

#include<stdio.h>

// Function to reverse array using an extra array
void reverseArrayBruteForce(int arr[], int n) {
    // Create a temporary array
    int temp[n];

    // Copy elements from original to temp in reverse order
    for (int i = 0; i < n; i++) {
        temp[i] = arr[n - 1 - i];
    }

    // Copy back reversed array into original
    for (int i = 0; i < n; i++) {
        arr[i] = temp[i];
    }
}

// Function to print array
void printArray(int arr[], int n) {
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

// Driver code
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);

    printf("Original Array: ");
    printArray(arr, n);

    reverseArrayBruteForce(arr, n);

    printf("Reversed Array (Brute Force): ");
    printArray(arr, n);

    return 0;
}

Complexity Analysis

Time Complexity: O(n), because we traverse the array twice.

Space Complexity: O(n), because we use an extra array.

Optimal Approach

Algorithm

We don’t really need extra space. If we use two pointers — one at the start and one at the end of the array and sw