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}
- 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];
}
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];
}
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];
}
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:" , end = " " )
for i in reversed_arr:
print (i, end = " " )
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];
}
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();
process.stdout.write( "Reversed Array: " );
reversedArr.forEach(element => process.stdout.write(element + " " ));
}
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++
#include <bits/stdc++.h>
using namespace std;
void rvereseArray( int arr[], int start, int end)
{
while (start < end)
{
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
void printArray( int arr[], int size)
{
for ( int i = 0; i < size; i++)
cout << arr[i] << " " ;
cout << endl;
}
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);
cout << "Reversed array is" << endl;
printArray(arr, n);
return 0;
}
|
C
#include<stdio.h>
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--;
}
}
void printArray( int arr[], int size)
{
int i;
for (i=0; i < size; i++)
printf ( "%d " , arr[i]);
printf ( "\n" );
}
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
public class GFG {
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--;
}
}
static void printArray( int arr[],
int size)
{
for ( int i = 0; i < size; i++)
System.out.print(arr[i] + " " );
System.out.println();
}
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);
}
}
|
Python3
def reverseList(A, start, end):
while start < end:
A[start], A[end] = A[end], A[start]
start + = 1
end - = 1
A = [ 1 , 2 , 3 , 4 , 5 , 6 ]
print (A)
reverseList(A, 0 , 5 )
print ( "Reversed list is" )
print (A)
|
C#
using System;
class GFG {
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--;
}
}
static void printArray( int []arr,
int size)
{
for ( int i = 0; i < size; i++)
Console.Write(arr[i] + " " );
Console.WriteLine();
}
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);
}
}
|
JavaScript
function rvereseArray(arr,start,end)
{
while (start < end)
{
var temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
function printArray(arr,size)
{
for ( var i = 0; i < size; i++){
console.log(arr[i]);
}
}
var arr= [1, 2, 3, 4, 5, 6];
var n = 6;
printArray(arr, n);
rvereseArray(arr, 0, n-1);
console.log( "Reversed array is" );
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
function rvereseArray(&$arr, $start,
$end)
{
while ($start < $end)
{
$temp = $arr[$start];
$arr[$start] = $arr[$end];
$arr[$end] = $temp;
$start++;
$end--;
}
}
function printArray(&$arr, $size)
{
for ($i = 0; $i < $size; $i++)
echo $arr[$i] . " " ;
echo "\n" ;
}
$arr = array(1, 2, 3, 4, 5, 6);
printArray($arr, 6);
rvereseArray($arr, 0, 5);
echo "Reversed array is" . "\n" ;
printArray($arr, 6);
?>
|
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]);
std::reverse(originalArray, originalArray + length);
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};
int [] reversedArray = new int [originalArray.length];
for ( int i = 0; i < originalArray.length; i++) {
reversedArray[i] = originalArray[originalArray.length - 1 - i];
}
System.out.println(Arrays.toString(reversedArray));
}
}
|
Python3
original_array = [ 1 , 2 , 3 , 4 , 5 ]
reversed_array = list ( reversed (original_array))
print (reversed_array)
|
C#
using System;
class Program {
static void Main() {
int [] originalArray = {1, 2, 3, 4, 5};
Array.Reverse(originalArray);
foreach ( int num in originalArray) {
Console.Write(num + " " );
}
}
}
|
JavaScript
let originalArray = [1, 2, 3, 4, 5];
let reversedArray = originalArray.slice().reverse();
console.log(reversedArray);
|
- 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++
#include <bits/stdc++.h>
using namespace std;
void rvereseArray( int arr[], int start, int end)
{
if (start >= end)
return ;
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
rvereseArray(arr, start + 1, end - 1);
}
void printArray( int arr[], int size)
{
for ( int i = 0; i < size; i++)
cout << arr[i] << " " ;
cout << endl;
}
int main()
{
int arr[] = {1, 2, 3, 4, 5, 6};
printArray(arr, 6);
rvereseArray(arr, 0, 5);
cout << "Reversed array is" << endl;
printArray(arr, 6);
return 0;
}
|
C
#include <stdio.h>
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);
}
void printArray( int arr[], int size)
{
int i;
for (i=0; i < size; i++)
printf ( "%d " , arr[i]);
printf ( "\n" );
}
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
import java.io.*;
class ReverseArray {
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);
}
static void printArray( int arr[], int size)
{
for ( int i=0; i < size; i++)
System.out.print(arr[i] + " " );
System.out.println( "" );
}
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);
}
}
|
Python3
def reverseList(A, start, end):
if start > = end:
return
A[start], A[end] = A[end], A[start]
reverseList(A, start + 1 , end - 1 )
A = [ 1 , 2 , 3 , 4 , 5 , 6 ]
print (A)
reverseList(A, 0 , 5 )
print ( "Reversed list is" )
print (A)
|
C#
using System;
class GFG
{
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);
}
static void printArray( int []arr, int size)
{
for ( int i = 0; i < size; i++)
Console.Write(arr[i] + " " );
Console.WriteLine( "" );
}
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);
}
}
|
JavaScript
function rvereseArray(arr,start,end)
{
var temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
if (start+1<end-1){
rvereseArray(arr, start + 1, end - 1);
}
}
function printArray(arr,size)
{
for ( var i = 0; i < size; i++){
console.log(arr[i]);
}
}
var arr= [1, 2, 3, 4, 5, 6];
printArray(arr, 6);
rvereseArray(arr, 0, 5);
console.log( "Reversed array is" );
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
function rvereseArray(&$arr,
$start, $end)
{
if ($start >= $end)
return ;
$temp = $arr[$start];
$arr[$start] = $arr[$end];
$arr[$end] = $temp;
rvereseArray($arr, $start + 1,
$end - 1);
}
function printArray(&$arr, $size)
{
for ($i = 0; $i < $size; $i++)
echo $arr[$i] . " " ;
echo "\n" ;
}
$arr = array(1, 2, 3, 4, 5, 6);
printArray($arr, 6);
rvereseArray($arr, 0, 5);
echo "Reversed array is" . "\n" ;
printArray($arr, 6);
?>
|
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;
for ( int i = 0; i < size; i++) {
stack.push(arr[i]);
}
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;
for ( int i = 0; i < size; i++) {
push(&stack, arr[i]);
}
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<>();
for ( int element : arr) {
stack.push(element);
}
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 = []
for element in arr:
stack.append(element)
for i in range ( len (arr)):
arr[i] = stack.pop()
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 >();
foreach ( int element in arr) {
stack.Push(element);
}
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 = [];
for (let i = 0; i < arr.length; i++) {
stack.push(arr[i]);
}
for (let i = 0; i < arr.length; i++) {
arr[i] = stack.pop();
}
}
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
Share your thoughts in the comments
Please Login to comment...