17. Reverse an Array

The problem can be found at the following link: Problem Link

🗳️ Cast Your Vote!

Have your say in shaping the future of our repository! Visit our active discussion poll and make your voice heard. 🌟

Note: I'm currently in the middle of my exams until November 19, so I’ll be uploading daily POTD solutions, but not at a fixed time. Apologies for any inconvenience, and thank you for your patience!

Problem Description

You are given an array of integers arr[]. Your task is to reverse the given array.

Examples:

Input: arr = [1, 4, 3, 2, 6, 5] Output: [5, 6, 2, 3, 4, 1]

Explanation: The elements of the array are 1 4 3 2 6 5. After reversing the array, the first element goes to the last position, the second element goes to the second-last position, and so on. Hence, the answer is [5, 6, 2, 3, 4, 1].

Input: arr = [4, 5, 2] Output: [2, 5, 4]

Explanation: The elements of the array are 4 5 2. The reversed array will be [2, 5, 4].

Input: arr = [1] Output: [1]

Explanation: The array has only a single element, hence the reversed array is the same as the original.

Constraints:

• 1 <= arr.size() <= 10^5

• 0 <= arr[i] <= 10^5

My Approach

1. Reversal Process:

   • The main idea is to reverse the array in-place by swapping elements from both ends.

   • We initialize two pointers: left at the beginning of the array and right at the end.

   • We swap arr[left] and arr[right], then move left forward and right backward until they cross each other.

   • This process effectively reverses the array.

2. Alternative Approaches:

   • XOR Swap Method: You can swap elements using XOR to avoid a temporary variable.

   • Using List Reverse: In some languages, you can simply call the reverse function on the array.

Time and Auxiliary Space Complexity

• Expected Time Complexity: O(n), where n is the number of elements in the array. We perform one pass through the array, swapping elements in place.

• Expected Auxiliary Space Complexity: O(1), as we only use a constant amount of additional space to track the left and right pointers.

Code (C)

void reverseArray(int arr[], int n) {
    int left = 0, right = n - 1;

    while (left < right) {
        arr[left] ^= arr[right];
        arr[right] ^= arr[left];
        arr[left] ^= arr[right];
        left++;
        right--;
    }
}

👨‍💻 Alternative Approaches

Alternative Approach (Using Temporary Variable)

void reverseArray(int arr[], int n) {
    int left = 0, right = n - 1;

    while (left < right) {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
        left++;
        right--;
    }
}

Code (CPP)

class Solution {
public:
    void reverseArray(std::vector<int>& arr) {
        std::reverse(arr.begin(), arr.end());
    }
};

👨‍💻 Alternative Approaches

Alternative Approach (Using std::swap)

class Solution {
public:
    void reverseArray(std::vector<int>& arr) {
        int left = 0, right = arr.size() - 1;

        while (left < right) {
            std::swap(arr[left], arr[right]);
            left++;
            right--;
        }
    }
};

Alternative Approach (Using XOR Swap)

class Solution {
public:
    void reverseArray(std::vector<int>& arr) {
        int left = 0, right = arr.size() - 1;

        while (left < right) {
            arr[left] ^= arr[right];
            arr[right] ^= arr[left];
            arr[left] ^= arr[right];
            left++;
            right--;
        }
    }
};

Code (Java)

class Solution {
    public void reverseArray(int[] arr) {
        Integer[] boxedArray = Arrays.stream(arr).boxed().toArray(Integer[]::new);
        List<Integer> list = Arrays.asList(boxedArray);
        Collections.reverse(list);
        for (int i = 0; i < arr.length; i++) {
            arr[i] = list.get(i);
        }
    }
}

👨‍💻 Alternative Approaches

Alternative Approach (Using XOR Swap)

class Solution {
    public void reverseArray(int[] arr) {
        int left = 0, right = arr.length - 1;

        while (left < right) {
            arr[left] = arr[left] ^ arr[right];
            arr[right] = arr[left] ^ arr[right];
            arr[left] = arr[left] ^ arr[right];
            left++;
            right--;
        }
    }
}

Code (Python)

class Solution:
    def reverseArray(self, arr):
        arr.reverse()

👨‍💻 Alternative Approaches

Alternative Approach (Using Swapping)

class Solution:
    def reverseArray(self, arr):
        left, right = 0, len(arr) - 1

        while left < right:
            arr[left], arr[right] = arr[right], arr[left]
            left += 1
            right -= 1

Contribution and Support

For discussions, questions, or doubts related to this solution, feel free to connect on LinkedIn: Any Questions. Let’s make this learning journey more collaborative!

⭐ If you find this helpful, please give this repository a star! ⭐

---

📍Visitor Count