Open In App
Related Articles

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

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

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

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 <iostream>
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 <stdio.h>
 
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.

reverse-a-number

Below is the implementation of the above approach : 

C++

// Iterative C++ program to reverse an array
#include <bits/stdc++.h>
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<stdio.h>
 
/* 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);
</code></pre></gfg-panel><gfg-tab slot="tab">PHP</gfg-tab><gfg-panel data-code-lang="php" slot="panel"><pre><code class="language-php"><?php
// Iterative PHP program
// to reverse an array
 
/* Function to reverse
$arr from start to end*/
function rvereseArray(&$arr, $start,
                    $end)
{
    while ($start < $end)
    {
        $temp = $arr[$start];
        $arr[$start] = $arr[$end];
        $arr[$end] = $temp;
        $start++;
        $end--;
    }
}    
 
/* 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 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 <iostream>
#include <algorithm> // 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 <bits/stdc++.h>
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 <stdio.h>
 
/* 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+1<end-1){
    rvereseArray(arr, start + 1, end - 1);
    }
}    
/* 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];
     
    // To print original array
    printArray(arr, 6);
     
    // Function calling
    rvereseArray(arr, 0, 5);
     
    console.log("Reversed array is");
     
    // To print the Reversed array
    printArray(arr, 6);
</code></pre></gfg-panel><gfg-tab slot="tab">PHP</gfg-tab><gfg-panel data-code-lang="php" slot="panel"><pre><code class="language-php"><?php
// Iterative PHP program
// to reverse an array
 
/* Function to reverse
$arr from start to end*/
function rvereseArray(&$arr,
                    $start, $end)
{
    if ($start >= $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 <iostream>
#include <stack>
#include <vector>
 
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 <stdio.h>
#include <stdlib.h>
 
#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<Integer> 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.


Last Updated : 31 Jan, 2024
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads