Program to reverse the rows in a 2d Array
Last Updated :
12 Jul, 2025
Given a 2D array arr[][] of size M x N integers where M is the number of rows and N is the number of columns. The task is to reverse every row of the given 2D array.
Example:
Input: arr[][] =
{ {1, 2, 3},
{4, 5, 6},
{7, 8, 9} }
Output:
3 2 1
6 5 4
9 8 7
Input: arr[][] =
{ {1, 2},
{4, 5},
{7, 8},
{9, 10} }
Output:
2 1
5 4
8 7
10 9
Approach:
- For every row in the given 2D array do the following:
- Initialise the start index as 0 and end index as N-1.
- Iterate loop till start index is less than ending index, swap the value at these indexes and update the index as:
swap(arr[i][start], arr[i][end])
start++;
end--;
2. Do the above operation for all the rows in the 2D array.
Below is the implementation of the above approach:
C++
// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
const int M = 3;
const int N = 3;
// A utility function
// to swap the two element
void swap(int* a, int* b)
{
int temp = *a;
*a = *b;
*b = temp;
}
// Function to reverse
// the given 2D arr[][]
void reverseArray(int arr[M][N])
{
// Traverse each row of arr[][]
for (int i = 0; i < M; i++) {
// Initialise start and end index
int start = 0;
int end = N - 1;
// Till start < end, swap the element
// at start and end index
while (start < end) {
// Swap the element
swap(&arr[i][start],
&arr[i][end]);
// Increment start and decrement
// end for next pair of swapping
start++;
end--;
}
}
// Print the arr[][] after
// reversing every row
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
cout << arr[i][j] << ' ';
}
cout << endl;
}
}
// Driver Code
int main()
{
int arr[][3] = { { 1, 2, 3 },
{ 4, 5, 6 },
{ 7, 8, 9 } };
// Function call
reverseArray(arr);
return 0;
}
// Java implementation of the above approach
class GFG{
static int M = 3;
static int N = 3;
// Function to reverse
// the given 2D arr[][]
static void reverseArray(int arr[][])
{
// Traverse each row of arr[][]
for (int i = 0; i < M; i++) {
// Initialise start and end index
int start = 0;
int end = N - 1;
// Till start < end, swap the element
// at start and end index
while (start < end) {
// Swap the element
int temp = arr[i][start];
arr[i][start] = arr[i][end];
arr[i][end] = temp;
// Increment start and decrement
// end for next pair of swapping
start++;
end--;
}
}
// Print the arr[][] after
// reversing every row
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
// Driver Code
public static void main(String[] args)
{
int arr[][] = { { 1, 2, 3 },
{ 4, 5, 6 },
{ 7, 8, 9 } };
// Function call
reverseArray(arr);
}
}
// This code is contributed by PrinciRaj1992
# Python3 implementation of the above approach
M = 3;N = 3;
# Function to reverse
# the given 2D arr[][]
def reverseArray(arr) :
# Traverse each row of arr[][]
for i in range(M) :
# Initialise start and end index
start = 0;
end = N - 1;
# Till start < end, swap the element
# at start and end index
while (start < end) :
# Swap the element
arr[i][start], arr[i][end] = arr[i][end], arr[i][start];
# Increment start and decrement
# end for next pair of swapping
start += 1;
end -= 1;
# Print the arr[][] after
# reversing every row
for i in range(M) :
for j in range(N) :
print(arr[i][j],end= ' ');
print();
# Driver Code
if __name__ == "__main__" :
arr = [ [ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ] ];
# Function call
reverseArray(arr);
# This code is contributed by AnkitRai01
// C# implementation of the above approach
using System;
class GFG{
static int M = 3;
static int N = 3;
// Function to reverse
// the given 2D [,]arr
static void reverseArray(int [,]arr)
{
// Traverse each row of [,]arr
for (int i = 0; i < M; i++) {
// Initialise start and end index
int start = 0;
int end = N - 1;
// Till start < end, swap the element
// at start and end index
while (start < end) {
// Swap the element
int temp = arr[i,start];
arr[i, start] = arr[i, end];
arr[i, end] = temp;
// Increment start and decrement
// end for next pair of swapping
start++;
end--;
}
}
// Print the [,]arr after
// reversing every row
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
Console.Write(arr[i, j] + " ");
}
Console.WriteLine();
}
}
// Driver Code
public static void Main(String[] args)
{
int [,]arr = { { 1, 2, 3 },
{ 4, 5, 6 },
{ 7, 8, 9 } };
// Function call
reverseArray(arr);
}
}
// This code is contributed by PrinciRaj1992
<script>
// JavaScript implementation of the above approach
const M = 3;
const N = 3;
// Function to reverse
// the given 2D arr
function reverseArray(arr) {
// Traverse each row of arr
for (i = 0; i < M; i++) {
// Initialise start and end index
var start = 0;
var end = N - 1;
// Till start < end, swap the element
// at start and end index
while (start < end) {
// Swap the element
var temp = arr[i][start];
arr[i][start] = arr[i][end];
arr[i][end] = temp;
// Increment start and decrement
// end for next pair of swapping
start++;
end--;
}
}
// Print the arr after
// reversing every row
for (i = 0; i < M; i++) {
for (j = 0; j < N; j++) {
document.write(arr[i][j] + " ");
}
document.write("<br/>");
}
}
// Driver Code
var arr = [ [ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ] ];
// Function call
reverseArray(arr);
// This code is contributed by todaysgaurav
</script>
Time Complexity: O(n*n)
Auxiliary Space: O(1)
Approach#2: Using list comprehension
This approach uses list comprehension to reverse the rows in the input 2D array. It first initializes an empty list and then iterates over each row of the input array, reversing each row using the [::-1] slicing notation and appending the reversed row to the empty list using the append() method. Finally, it prints the reversed array using nested loops.
Algorithm
1. Initialize an empty list.
2. For each row in the input array:
a. Reverse the row using the slicing notation [::-1].
b. Append the reversed row to the empty list using the append() method.
3. Print the reversed array using nested loops.
C++
#include <algorithm> // Include this header for the reverse function
#include <iostream>
#include <vector>
int main()
{
// Input array
std::vector<std::vector<int> > arr
= { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
// Reverse the rows in the array using a loop and vector
for (int i = 0; i < arr.size(); ++i) {
std::vector<int>& row = arr[i];
std::reverse(row.begin(), row.end());
}
// Print the reversed array
for (int i = 0; i < arr.size(); ++i) {
for (int j = 0; j < arr[i].size(); ++j) {
std::cout << arr[i][j] << " ";
}
std::cout << std::endl;
}
return 0;
}
import java.util.ArrayList;
import java.util.Collections;
public class GFG {
public static void main(String[] args) {
// Input array
ArrayList<ArrayList<Integer>> arr = new ArrayList<ArrayList<Integer>>();
arr.add(new ArrayList<Integer>() {{
add(1);
add(2);
add(3);
}});
arr.add(new ArrayList<Integer>() {{
add(4);
add(5);
add(6);
}});
arr.add(new ArrayList<Integer>() {{
add(7);
add(8);
add(9);
}});
// Reverse the rows in the array using a loop and ArrayList
for (int i = 0; i < arr.size(); i++) {
Collections.reverse(arr.get(i));
}
// Print the reversed array
for (int i = 0; i < arr.size(); i++) {
for (int j = 0; j < arr.get(i).size(); j++) {
System.out.print(arr.get(i).get(j) + " ");
}
System.out.println();
}
}
}
# Input array
arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# Reverse the rows in the array using list comprehension
arr = [row[::-1] for row in arr]
# Print the reversed array
for i in range(len(arr)):
for j in range(len(arr[i])):
print(arr[i][j], end=" ")
print()
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
// Input 2D array
List<List<int>> arr = new List<List<int>>
{
new List<int> {1, 2, 3},
new List<int> {4, 5, 6},
new List<int> {7, 8, 9}
};
// Reverse the rows in the array using a loop and List.Reverse method
for (int i = 0; i < arr.Count; ++i)
{
List<int> row = arr[i];
row.Reverse();
}
// Print the reversed array
for (int i = 0; i < arr.Count; ++i)
{
for (int j = 0; j < arr[i].Count; ++j)
{
Console.Write(arr[i][j] + " ");
}
Console.WriteLine();
}
}
}
// Reverse function is available in JavaScript, no need to include any header
// Input array
let arr = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
];
// Reverse the rows in the array using a loop and array methods
for (let i = 0; i < arr.length; ++i) {
let row = arr[i];
row.reverse(); // Reverse the row
}
// Print the reversed array
for (let i = 0; i < arr.length; ++i) {
for (let j = 0; j < arr[i].length; ++j) {
console.log(arr[i][j] + " ");
}
console.log(""); // Print a new line after each row
}
Time complexity: O(mn), where m is the number of rows and n is the number of columns in the input array. The code iterates over each element of the input array once to reverse the rows and again to print the reversed array.
Auxiliary Space: O(mn), where m is the number of rows and n is the number of columns in the input array. The code initializes an empty list of size m and then appends n elements to it for each row of the input array, resulting in a total of m*n elements.
Similar Reads
Program to reverse an array using pointers Prerequisite : Pointers in C/C++ Given an array, write a program to reverse it using pointers . In this program we make use of * operator . The * (asterisk) operator denotes the value of variable . The * operator at the time of declaration denotes that this is a pointer, otherwise it denotes the val
4 min read
Program to reverse columns in given 2D Array (Matrix) Given a 2D array arr[][]of integers of size M x N, where N is the number of columns and M is the number of rows in the array. The task is to reverse every column of the given 2D array Input: arr[][] = {{3, 2, 1} {4, 5, 6}, {9, 8, 7}} Output: 9 8 7 4 5 6 3 2 1 Input: arr[][] = {{7, 9}, {1, 5}, {4, 6}
7 min read
Reverse an array upto a given position Given an array arr[] and a position in array, k. Write a function name reverse (a[], k) such that it reverses subarray arr[0..k-1]. Extra space used should be O(1) and time complexity should be O(k). Example: Input: arr[] = {1, 2, 3, 4, 5, 6} k = 4 Output: arr[] = {4, 3, 2, 1, 5, 6} We strongly reco
6 min read
Program to Reverse the subarray in between given range Given an array arr and a range [L, R], the task is to reverse the subarray in between the given range [L, R]. Examples: Input: arr = [1, 2, 3, 4, 5, 6, 7], L = 1, R = 5Output: [1, 6, 5, 4, 3, 2, 7] Input: arr = [10, 20, 30, 40, 50], L = 0, R = 2Output: [30, 20, 10, 40, 50] Recommended PracticeRevers
7 min read
Reverse the rows and columns of a matrix alternatively Given a matrix arr[][] of size M*N, where M is the number of rows and N is the number of columns. The task is to reverse the rows and columns of the matrix alternatively i.e start with reversing the 1st row, then the 2nd column, and so on. Examples: Input: arr[][] = { {3, 4, 1, 8}, {11, 23, 43, 21},
7 min read
Reversal algorithm for Array rotation Given an array arr[] of size N, the task is to rotate the array by d position to the left. Examples: Input: arr[] = {1, 2, 3, 4, 5, 6, 7}, d = 2Output: 3, 4, 5, 6, 7, 1, 2Explanation: If the array is rotated by 1 position to the left, it becomes {2, 3, 4, 5, 6, 7, 1}.When it is rotated further by 1
15 min read