# Array Reverse in C/C++/Java/Python/JavaScript

Array reverse or reverse a array means changing the position of each number of the given array to its opposite position from end, i.e. if a number is at position 1 then its new position will be Array.length, similarly if a number is at position 2 then its new position will be Array.length – 1, and so on.

Array Reverse in C/C++/Java/Python/JavaScript

Given an array (or string), the task is to reverse the array/string.

Examples:

Input: original_array[] = {1, 2, 3} Output: array_reversed[] = {3, 2, 1}

Input: original_array[] = {4, 5, 1, 2}
Output: array_reversed[] = {2, 1, 5, 4}

## 1. Array Reverse Using an Extra Array (Non In-place):

• Create a new array of the same size as the original array.
• Copy elements from the original array to the new array in reverse order.

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `void` `reverseArrayExtraArray(``int` `arr[], ``int` `size) {``    ``int` `reversedArr[size];``    ``for` `(``int` `i = 0; i < size; i++) {``        ``reversedArr[i] = arr[size - i - 1];``    ``}` `    ``// Print reversed array``    ``cout << ``"Reversed Array: "``;``    ``for` `(``int` `i = 0; i < size; i++) {``        ``std::cout << reversedArr[i] << ``" "``;``    ``}``}` `int` `main() {``    ``int` `originalArr[] = {1, 2, 3, 4, 5};``    ``int` `size = ``sizeof``(originalArr) / ``sizeof``(originalArr[0]);``    ` `    ``reverseArrayExtraArray(originalArr, size);``}`

## C

 `#include ` `void` `reverseArrayExtraArray(``int` `arr[], ``int` `size) {``    ``int` `reversedArr[size];``    ``for` `(``int` `i = 0; i < size; i++) {``        ``reversedArr[i] = arr[size - i - 1];``    ``}` `    ``// Print reversed array``    ``printf``(``"Reversed Array: "``);``    ``for` `(``int` `i = 0; i < size; i++) {``        ``printf``(``"%d "``, reversedArr[i]);``    ``}``}` `int` `main() {``    ``int` `originalArr[] = {1, 2, 3, 4, 5};``    ``int` `size = ``sizeof``(originalArr) / ``sizeof``(originalArr[0]);``    ` `    ``reverseArrayExtraArray(originalArr, size);` `    ``return` `0;``}`

## Java

 `public` `class` `ReverseArrayExtraArray {``    ``public` `static` `void` `reverseArrayExtraArray(``int``[] arr) {``        ``int``[] reversedArr = ``new` `int``[arr.length];``        ``for` `(``int` `i = 0; i < arr.length; i++) {``            ``reversedArr[i] = arr[arr.length - i - 1];``        ``}` `        ``// Print reversed array``        ``System.out.print(``"Reversed Array: "``);``        ``for` `(``int` `i : reversedArr) {``            ``System.out.print(i + ``" "``);``        ``}``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``int``[] originalArr = {1, 2, 3, 4, 5};``        ``reverseArrayExtraArray(originalArr);``    ``}``}`

## Python3

 `def` `reverse_array_extra_array(arr):``    ``reversed_arr ``=` `arr[::``-``1``]` `    ``# Print reversed array``    ``print``(``"Reversed Array:"``, end``=``" "``)``    ``for` `i ``in` `reversed_arr:``        ``print``(i, end``=``" "``)` `# Example usage:``original_arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``]``reverse_array_extra_array(original_arr)`

## C#

 `using` `System;` `class` `Program {``    ``static` `void` `ReverseArrayExtraArray(``int``[] arr) {``        ``int``[] reversedArr = ``new` `int``[arr.Length];``        ``for` `(``int` `i = 0; i < arr.Length; i++) {``            ``reversedArr[i] = arr[arr.Length - i - 1];``        ``}` `        ``// Print reversed array``        ``Console.Write(``"Reversed Array: "``);``        ``foreach` `(``int` `num ``in` `reversedArr) {``            ``Console.Write(num + ``" "``);``        ``}``    ``}` `    ``static` `void` `Main() {``        ``int``[] originalArr = {1, 2, 3, 4, 5};``        ``ReverseArrayExtraArray(originalArr);``    ``}``}`

## JavaScript

 `function` `reverseArrayExtraArray(arr) {``    ``const reversedArr = arr.slice().reverse();` `    ``// Print reversed array``    ``process.stdout.write(``"Reversed Array: "``);``    ``reversedArr.forEach(element => process.stdout.write(element + ``" "``));``}` `// Example usage:``const originalArr = [1, 2, 3, 4, 5];``reverseArrayExtraArray(originalArr);`

Output
```Reversed Array: 5 4 3 2 1
```
• Time Complexity: O(n)
• Copying elements to a new array is a linear operation.
• Auxiliary Space Complexity: O(n)
• Additional space is used to store the new array.

## 2. Array Reverse Using a Loop (In-place):

• Iterate through the array using two pointers (start and end).
• Swap elements at the start and end pointers.
• Move the start pointer towards the end and the end pointer towards the start until they meet or cross each other.

Below is the implementation of the above approach :Â

## C++

 `// Iterative C++ program to reverse an array ``#include ``using` `namespace` `std; ` `/* Function to reverse arr[] from start to end*/``void` `rvereseArray(``int` `arr[], ``int` `start, ``int` `end) ``{ ``    ``while` `(start < end) ``    ``{ ``        ``int` `temp = arr[start]; ``        ``arr[start] = arr[end]; ``        ``arr[end] = temp; ``        ``start++; ``        ``end--; ``    ``} ``}     ` `/* Utility function to print an array */``void` `printArray(``int` `arr[], ``int` `size) ``{ ``for` `(``int` `i = 0; i < size; i++) ``cout << arr[i] << ``" "``; ` `cout << endl; ``} ` `/* Driver function to test above functions */``int` `main() ``{ ``    ``int` `arr[] = {1, 2, 3, 4, 5, 6}; ``    ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ` `    ``// To print original array ``    ``printArray(arr, n); ``    ` `    ``// Function calling ``    ``rvereseArray(arr, 0, n-1); ``    ` `    ``cout << ``"Reversed array is"` `<< endl; ``    ` `    ``// To print the Reversed array ``    ``printArray(arr, n); ``    ` `    ``return` `0; ``} `

## C

 `// Iterative C program to reverse an array ``#include ` `/* Function to reverse arr[] from start to end*/``void` `rvereseArray(``int` `arr[], ``int` `start, ``int` `end) ``{ ``    ``int` `temp; ``    ``while` `(start < end) ``    ``{ ``        ``temp = arr[start]; ``        ``arr[start] = arr[end]; ``        ``arr[end] = temp; ``        ``start++; ``        ``end--; ``    ``} ``}     ` `/* Utility that prints out an array on a line */``void` `printArray(``int` `arr[], ``int` `size) ``{ ``int` `i; ``for` `(i=0; i < size; i++) ``    ``printf``(``"%d "``, arr[i]); ` `printf``(``"\n"``); ``} ` `/* Driver function to test above functions */``int` `main() ``{ ``    ``int` `arr[] = {1, 2, 3, 4, 5, 6}; ``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ``    ``printArray(arr, n); ``    ``rvereseArray(arr, 0, n-1); ``    ``printf``(``"Reversed array is \n"``); ``    ``printArray(arr, n);     ``    ``return` `0; ``} `

## Java

 `// Iterative java program to reverse an ``// array ``public` `class` `GFG { ``    ` `/* Function to reverse arr[] from ``    ``start to end*/``    ``static` `void` `rvereseArray(``int` `arr[], ``                    ``int` `start, ``int` `end) ``    ``{ ``        ``int` `temp; ``        ` `        ``while` `(start < end) ``        ``{ ``            ``temp = arr[start]; ``            ``arr[start] = arr[end]; ``            ``arr[end] = temp; ``            ``start++; ``            ``end--; ``        ``} ``    ``}     ``    ` `    ``/* Utility that prints out an ``    ``array on a line */``    ``static` `void` `printArray(``int` `arr[], ``                            ``int` `size) ``    ``{ ``        ``for` `(``int` `i = 0; i < size; i++) ``            ``System.out.print(arr[i] + ``" "``); ``        ` `        ``System.out.println(); ``    ``} ` `    ``// Driver code ``    ``public` `static` `void` `main(String args[]) { ``        ` `        ``int` `arr[] = {1, 2, 3, 4, 5, 6}; ``        ``printArray(arr, 6); ``        ``rvereseArray(arr, 0, 5); ``        ``System.out.print(``"Reversed array is \n"``); ``        ``printArray(arr, 6); ``        ` `    ``} ``} ` `// This code is contributed by Sam007 `

## Python3

 `# Iterative python program to reverse an array ` `# Function to reverse A[] from start to end ``def` `reverseList(A, start, end): ``    ``while` `start < end: ``        ``A[start], A[end] ``=` `A[end], A[start] ``        ``start ``+``=` `1``        ``end ``-``=` `1` `# Driver function to test above function ``A ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``6``] ``print``(A) ``reverseList(A, ``0``, ``5``) ``print``(``"Reversed list is"``) ``print``(A) ``# This program is contributed by Pratik Chhajer `

## C#

 `// Iterative C# program to reverse an ``// array ``using` `System; ` `class` `GFG { ` `    ``/* Function to reverse arr[] from ``    ``start to end*/``    ``static` `void` `rvereseArray(``int` `[]arr, ``                    ``int` `start, ``int` `end) ``    ``{ ``        ``int` `temp; ``        ` `        ``while` `(start < end) ``        ``{ ``            ``temp = arr[start]; ``            ``arr[start] = arr[end]; ``            ``arr[end] = temp; ``            ``start++; ``            ``end--; ``        ``} ``    ``}     ``    ` `    ``/* Utility that prints out an ``    ``array on a line */``    ``static` `void` `printArray(``int` `[]arr, ``                            ``int` `size) ``    ``{ ``        ``for` `(``int` `i = 0; i < size; i++) ``            ``Console.Write(arr[i] + ``" "``); ``        ` `        ``Console.WriteLine(); ``    ``} ``    ` `    ``// Driver function ``    ``public` `static` `void` `Main() ``    ``{ ``        ``int` `[]arr = {1, 2, 3, 4, 5, 6}; ``        ``printArray(arr, 6); ``        ``rvereseArray(arr, 0, 5); ``        ``Console.Write(``"Reversed array is \n"``); ``        ``printArray(arr, 6); ``    ``} ``} ` `// This code is contributed by Sam007 `

## JavaScript

 `// Iterative Javascript program to reverse an array ` `/* Function to reverse arr[] from start to end*/``function` `rvereseArray(arr,start,end) ``{ ``    ``while` `(start < end) ``    ``{ ``        ``var` `temp = arr[start]; ``        ``arr[start] = arr[end]; ``        ``arr[end] = temp; ``        ``start++; ``        ``end--; ``    ``} ``}     ` `/* Utility function to print an array */``function` `printArray(arr,size) ``{ ``for` `(``var` `i = 0; i < size; i++){ ``console.log(arr[i]); ``} ``} ` `/* Driver function to test above functions */``    ``var` `arr= [1, 2, 3, 4, 5, 6]; ``    ``var` `n = 6; ``    ``// To print original array ``    ``printArray(arr, n); ``    ` `    ``// Function calling ``    ``rvereseArray(arr, 0, n-1); ``    ` `    ``console.log(``"Reversed array is"``); ``    ` `    ``// To print the Reversed array ``    ``printArray(arr, n); ``PHP
`

Output
```1 2 3 4 5 6
Reversed array is
6 5 4 3 2 1

```
• Time Complexity: O(n)
• The loop runs through half of the array, so it’s linear with respect to the array size.
• Auxiliary Space Complexity: O(1)
• In-place reversal, meaning it doesn’t use additional space.

## 3. Array Reverse Inbuilt Methods (Non In-place):

• Use inbuilt methods like `reverse` in Python or `Array.Reverse` in C#.

Below is the implementation of the above approach :Â

## C++

 `#include ``#include // for std::reverse` `int` `main() {``    ``int` `originalArray[] = {1, 2, 3, 4, 5};``    ``int` `length = ``sizeof``(originalArray) / ``sizeof``(originalArray[0]);` `    ``// Using inbuilt method in C++``    ``std::reverse(originalArray, originalArray + length);` `    ``// Print the reversed array``    ``for` `(``int` `i = 0; i < length; i++) {``        ``std::cout << originalArray[i] << ``" "``;``    ``}` `    ``return` `0;``}`

## Java

 `import java.util.Arrays;` `public` `class` `ArrayReverse {``    ``public` `static` `void` `main(String[] args) {``        ``int``[] originalArray = {1, 2, 3, 4, 5};` `        ``// Using inbuilt method in Java``        ``int``[] reversedArray = ``new` `int``[originalArray.length];``        ``for` `(``int` `i = 0; i < originalArray.length; i++) {``            ``reversedArray[i] = originalArray[originalArray.length - 1 - i];``        ``}` `        ``// Print the reversed array``        ``System.out.println(Arrays.toString(reversedArray));``    ``}``}`

## Python3

 `original_array ``=` `[``1``, ``2``, ``3``, ``4``, ``5``]` `# Using inbuilt method in Python``reversed_array ``=` `list``(``reversed``(original_array))` `# Print the reversed array``print``(reversed_array)`

## C#

 `using` `System;` `class` `Program {``    ``static` `void` `Main() {``        ``int``[] originalArray = {1, 2, 3, 4, 5};` `        ``// Using inbuilt method in C#``        ``Array.Reverse(originalArray);` `        ``// Print the reversed array``        ``foreach` `(``int` `num ``in` `originalArray) {``            ``Console.Write(num + ``" "``);``        ``}``    ``}``}`

## JavaScript

 `let originalArray = [1, 2, 3, 4, 5];` `// Using inbuilt method in JavaScript``let reversedArray = originalArray.slice().reverse();` `// Print the reversed array``console.log(reversedArray);`

Output
```5 4 3 2 1
```
• Time Complexity: O(n) The `reverse` method typically has linear time complexity.
• Auxiliary Space Complexity: O(n)
• Additional space is used to store the reversed array.

## 4. Array Reverse Recursion (In-place or Non In-place):

• Define a recursive function that takes an array as input.
• Swap the first and last elements.
• Recursively call the function with the remaining subarray.

Below is the implementation of the above approach :Â

## C++

 `// Recursive C++ program to reverse an array ``#include ``using` `namespace` `std; ` `/* Function to reverse arr[] from start to end*/``void` `rvereseArray(``int` `arr[], ``int` `start, ``int` `end) ``{ ``    ``if` `(start >= end) ``    ``return``; ``    ` `    ``int` `temp = arr[start]; ``    ``arr[start] = arr[end]; ``    ``arr[end] = temp; ``    ` `    ``// Recursive Function calling ``    ``rvereseArray(arr, start + 1, end - 1); ``}     `  `/* Utility function to print an array */``void` `printArray(``int` `arr[], ``int` `size) ``{ ``for` `(``int` `i = 0; i < size; i++) ``cout << arr[i] << ``" "``; ` `cout << endl; ``} ` `/* Driver function to test above functions */``int` `main() ``{ ``    ``int` `arr[] = {1, 2, 3, 4, 5, 6}; ``    ` `    ``// To print original array ``    ``printArray(arr, 6); ``    ` `    ``// Function calling ``    ``rvereseArray(arr, 0, 5); ``    ` `    ``cout << ``"Reversed array is"` `<< endl; ``    ` `    ``// To print the Reversed array ``    ``printArray(arr, 6); ``    ` `    ``return` `0; ``} `

## C

 `// Recursive C program to reverse an array ``#include ` `/* Function to reverse arr[] from start to end*/``void` `rvereseArray(``int` `arr[], ``int` `start, ``int` `end) ``{ ``int` `temp; ``if` `(start >= end) ``    ``return``; ``temp = arr[start]; ``arr[start] = arr[end]; ``arr[end] = temp; ``rvereseArray(arr, start+1, end-1); ``}     ` `/* Utility that prints out an array on a line */``void` `printArray(``int` `arr[], ``int` `size) ``{ ``int` `i; ``for` `(i=0; i < size; i++) ``    ``printf``(``"%d "``, arr[i]); ` `printf``(``"\n"``); ``} ` `/* Driver function to test above functions */``int` `main() ``{ ``    ``int` `arr[] = {1, 2, 3, 4, 5, 6}; ``    ``printArray(arr, 6); ``    ``rvereseArray(arr, 0, 5); ``    ``printf``(``"Reversed array is \n"``); ``    ``printArray(arr, 6);     ``    ``return` `0; ``} `

## Java

 `// Recursive Java Program to reverse an array ``import java.io.*; ` `class` `ReverseArray { ` `    ``/* Function to reverse arr[] from start to end*/``    ``static` `void` `rvereseArray(``int` `arr[], ``int` `start, ``int` `end) ``    ``{ ``        ``int` `temp; ``        ``if` `(start >= end) ``            ``return``; ``        ``temp = arr[start]; ``        ``arr[start] = arr[end]; ``        ``arr[end] = temp; ``        ``rvereseArray(arr, start+1, end-1); ``    ``} ` `    ``/* Utility that prints out an array on a line */``    ``static` `void` `printArray(``int` `arr[], ``int` `size) ``    ``{ ``        ``for` `(``int` `i=0; i < size; i++) ``            ``System.out.print(arr[i] + ``" "``); ``        ``System.out.println(``""``); ``    ``} ` `    ``/*Driver function to check for above functions*/``    ``public` `static` `void` `main (String[] args) { ``        ``int` `arr[] = {1, 2, 3, 4, 5, 6}; ``        ``printArray(arr, 6); ``        ``rvereseArray(arr, 0, 5); ``        ``System.out.println(``"Reversed array is "``); ``        ``printArray(arr, 6); ``    ``} ``} ``/*This article is contributed by Devesh Agrawal*/`

## Python3

 `# Recursive python program to reverse an array ` `# Function to reverse A[] from start to end ``def` `reverseList(A, start, end): ``    ``if` `start >``=` `end: ``        ``return``    ``A[start], A[end] ``=` `A[end], A[start] ``    ``reverseList(A, start``+``1``, end``-``1``) ` `# Driver function to test above function ``A ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``6``] ``print``(A) ``reverseList(A, ``0``, ``5``) ``print``(``"Reversed list is"``) ``print``(A) ``# This program is contributed by Pratik Chhajer `

## C#

 `// C# program to reverse an array ``using` `System; ` `class` `GFG ``{ ``    ``/* Function to reverse arr[] ``    ``from start to end*/``    ``static` `void` `rvereseArray(``int` `[]arr, ``int` `start, ``                                        ``int` `end) ``    ``{ ``        ``int` `temp; ``        ``if` `(start >= end) ``            ``return``; ``            ` `        ``temp = arr[start]; ``        ``arr[start] = arr[end]; ``        ``arr[end] = temp; ``        ` `        ``rvereseArray(arr, start+1, end-1); ``    ``} ` `    ``/* Utility that prints out an ``    ``array on a line */``    ``static` `void` `printArray(``int` `[]arr, ``int` `size) ``    ``{ ``        ``for` `(``int` `i = 0; i < size; i++) ``            ``Console.Write(arr[i] + ``" "``); ``    ` `        ``Console.WriteLine(``""``); ``    ``} ` `    ``// Driver Code ``    ``public` `static` `void` `Main () ``    ``{ ``        ``int` `[]arr = {1, 2, 3, 4, 5, 6}; ``        ` `        ``printArray(arr, 6); ``        ``rvereseArray(arr, 0, 5); ``        ` `        ``Console.WriteLine(``"Reversed array is "``); ``        ``printArray(arr, 6); ``    ``} ``} ` `// This code is contributed by Sam007 `

## JavaScript

 `// Recursive Javascript program to reverse an array ` `/* Function to reverse arr[] from start to end*/``function` `rvereseArray(arr,start,end) ``{ ``    ``var` `temp = arr[start]; ``    ``arr[start] = arr[end]; ``    ``arr[end] = temp; ``    ` `// Recursive Function calling ``    ``if` `(start+1PHP
= \$end) ``    ``return``; ``    ` `    ``\$temp = \$arr[\$start]; ``    ``\$arr[\$start] = \$arr[\$end]; ``    ``\$arr[\$end] = \$temp; ` `    ``//Recursive Function calling ``    ``rvereseArray(\$arr, \$start + 1, ``                    ``\$end - 1); ``}     ` `/* Utility function ``to print an array */``function` `printArray(&\$arr, \$size) ``{ ``for` `(\$i = 0; \$i < \$size; \$i++) ``echo \$arr[\$i] . ``" "``; ` `echo ``"\n"``; ``} ` `// Driver code ``\$arr = array(1, 2, 3, 4, 5, 6); ` `// To print original array ``printArray(\$arr, 6); ` `// Function calling ``rvereseArray(\$arr, 0, 5); ` `echo ``"Reversed array is"` `.``"\n"``; ` `// To print the Reversed array ``printArray(\$arr, 6); ` `// This code is contributed ``// by ChitraNayal ``?> `

Output
```1 2 3 4 5 6
Reversed array is
6 5 4 3 2 1

```
• Time Complexity: O(n). The recursion goes through each element once, so it’s linear.
• Auxiliary Space Complexity: O(n) for non in-place, O(log n) for in-place (due to recursion stack).

## 5. Array Reverse Stack (Non In-place):

• Push each element of the array onto a stack.
• Pop elements from the stack to form the reversed array.

Below is the implementation of the above approach :Â

## C++

 `#include ``#include ``#include ` `void` `reverseArrayUsingStack(``int` `arr[], ``int` `size) {``    ``std::stack<``int``> stack;` `    ``// Push elements onto the stack``    ``for` `(``int` `i = 0; i < size; i++) {``        ``stack.push(arr[i]);``    ``}` `    ``// Pop elements from the stack to reverse the array``    ``for` `(``int` `i = 0; i < size; i++) {``        ``arr[i] = stack.top();``        ``stack.pop();``    ``}``}` `int` `main() {``    ``int` `arr[] = {1, 2, 3, 4, 5};``    ``int` `size = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``reverseArrayUsingStack(arr, size);` `    ``std::cout << ``"Reversed Array: "``;``    ``for` `(``int` `i = 0; i < size; i++) {``        ``std::cout << arr[i] << ``" "``;``    ``}` `    ``return` `0;``}`

## C

 `#include ``#include ` `#define MAX_SIZE 100` `struct` `Stack {``    ``int` `arr[MAX_SIZE];``    ``int` `top;``};` `void` `push(``struct` `Stack* stack, ``int` `element) {``    ``if` `(stack->top == MAX_SIZE - 1) {``        ``printf``(``"Stack Overflow\n"``);``        ``return``;``    ``}``    ``stack->arr[++stack->top] = element;``}` `int` `pop(``struct` `Stack* stack) {``    ``if` `(stack->top == -1) {``        ``printf``(``"Stack Underflow\n"``);``        ``exit``(1);``    ``}``    ``return` `stack->arr[stack->top--];``}` `void` `reverseArrayUsingStack(``int` `arr[], ``int` `size) {``    ``struct` `Stack stack;``    ``stack.top = -1;` `    ``// Push elements onto the stack``    ``for` `(``int` `i = 0; i < size; i++) {``        ``push(&stack, arr[i]);``    ``}` `    ``// Pop elements from the stack to reverse the array``    ``for` `(``int` `i = 0; i < size; i++) {``        ``arr[i] = pop(&stack);``    ``}``}` `int` `main() {``    ``int` `arr[] = {1, 2, 3, 4, 5};``    ``int` `size = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``reverseArrayUsingStack(arr, size);` `    ``printf``(``"Reversed Array: "``);``    ``for` `(``int` `i = 0; i < size; i++) {``        ``printf``(``"%d "``, arr[i]);``    ``}` `    ``return` `0;``}`

## Java

 `import java.util.Stack;` `public` `class` `ReverseArrayUsingStack {``    ``public` `static` `void` `reverseArrayUsingStack(``int``[] arr) {``        ``Stack stack = ``new` `Stack<>();` `        ``// Push elements onto the stack``        ``for` `(``int` `element : arr) {``            ``stack.push(element);``        ``}` `        ``// Pop elements from the stack to reverse the array``        ``for` `(``int` `i = 0; i < arr.length; i++) {``            ``arr[i] = stack.pop();``        ``}``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``int``[] arr = {1, 2, 3, 4, 5};` `        ``reverseArrayUsingStack(arr);` `        ``System.out.print(``"Reversed Array: "``);``        ``for` `(``int` `element : arr) {``            ``System.out.print(element + ``" "``);``        ``}``    ``}``}`

## Python3

 `def` `reverse_array_using_stack(arr):``    ``stack ``=` `[]``    ` `    ``# Push elements onto the stack``    ``for` `element ``in` `arr:``        ``stack.append(element)``    ` `    ``# Pop elements from the stack to reverse the array``    ``for` `i ``in` `range``(``len``(arr)):``        ``arr[i] ``=` `stack.pop()` `# Example usage:``arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``]``reverse_array_using_stack(arr)``print``(``"Reversed Array:"``, arr)`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `Program {``    ``static` `void` `ReverseArrayUsingStack(``int``[] arr) {``        ``Stack<``int``> stack = ``new` `Stack<``int``>();` `        ``// Push elements onto the stack``        ``foreach` `(``int` `element ``in` `arr) {``            ``stack.Push(element);``        ``}` `        ``// Pop elements from the stack to reverse the array``        ``for` `(``int` `i = 0; i < arr.Length; i++) {``            ``arr[i] = stack.Pop();``        ``}``    ``}` `    ``static` `void` `Main() {``        ``int``[] arr = {1, 2, 3, 4, 5};` `        ``ReverseArrayUsingStack(arr);` `        ``Console.Write(``"Reversed Array: "``);``        ``foreach` `(``int` `element ``in` `arr) {``            ``Console.Write(element + ``" "``);``        ``}``    ``}``}`

## JavaScript

 `function` `reverseArrayUsingStack(arr) {``    ``let stack = [];``    ` `    ``// Push elements onto the stack``    ``for` `(let i = 0; i < arr.length; i++) {``        ``stack.push(arr[i]);``    ``}` `    ``// Pop elements from the stack to reverse the array``    ``for` `(let i = 0; i < arr.length; i++) {``        ``arr[i] = stack.pop();``    ``}``}` `// Example usage:``let arr = [1, 2, 3, 4, 5];``reverseArrayUsingStack(arr);``console.log(``"Reversed Array:"``, arr);`

Output
```Reversed Array: 5 4 3 2 1
```
• Time Complexity: O(n)
• Pushing and popping each element onto/from the stack requires linear time.
• Auxiliary Space Complexity: O(n)
• Additional space is used to store the stack.

Previous
Next