Open in App
Not now

# Program to reverse columns in given 2D Array (Matrix)

• Difficulty Level : Easy
• Last Updated : 19 Sep, 2022

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},
{19, 3}}

Output:  19 3
4 6
1 5
7 9

## Program to reverse columns in given 2D Array (Matrix) using swap function:

Follow the given steps to solve the problem:

• Initialize the start index as 0 and the end index as M – 1.
• Iterate a for loop till the start index is less than the ending index, swap the value at these indexes and update the index as:

swap(arr[start][i], arr[end][i]);
start++;
end–;

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
// for swapping two elements.
void swap(int* a, int* b)
{
int temp = *a;
*a = *b;
*b = temp;
}

// Print the arr[][]
void printMatrix(int arr[M][N])
{

for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
cout << arr[i][j] << ' ';
}
cout << endl;
}
}

// Function to reverse
// the given 2D arr[][]
void reverseColumnArray(int arr[M][N])
{

// Print the arr[][] before
// reversing every column
printMatrix(arr);
cout << endl;

// Traverse each column of arr[][]
for (int i = 0; i < N; i++) {
// Initialise start and end index
int start = 0;
int end = M - 1;

// Till start < end, swap the
// element at start and end index
while (start < end) {
// Swap the element
swap(&arr[start][i], &arr[end][i]);

// Increment start and decrement
// end for next pair of swapping
start++;
end--;
}
}

// Print the arr[][] after
// reversing every column
printMatrix(arr);
}

// Driver Code
int main()
{
int arr[][3]
= { { 3, 2, 1 }, { 4, 5, 6 }, { 9, 8, 7 } };

// Function call
reverseColumnArray(arr);
return 0;
}```

## Java

```// Java implementation of the
// above approach
import java.util.*;
class GFG {

static int M = 3;
static int N = 3;

// A utility function
// for swapping two elements.
private static int[][] swap(int[][] arr, int start,
int i, int end, int j)
{

int temp = arr[start][i];
arr[start][i] = arr[end][j];
arr[end][j] = temp;
return arr;
}

// Print the arr[][]
static void printMatrix(int arr[][])
{

for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}

// Function to reverse
// the given 2D arr[][]
static void reverseColumnArray(int arr[][])
{

// Print the arr[][] before
// reversing every column
printMatrix(arr);
System.out.println();

// Traverse each column of arr[][]
for (int i = 0; i < N; i++) {
// Initialise start and end index
int start = 0;
int end = M - 1;

// Till start < end, swap the
// element at start and end index
while (start < end) {

// Swap the element
arr = swap(arr, start, i, end, i);

// Increment start and decrement
// end for next pair of swapping
start++;
end--;
}
}

// Print the arr[][] after
// reversing every column
printMatrix(arr);
}

// Driver Code
public static void main(String[] args)
{
int arr[][]
= { { 3, 2, 1 }, { 4, 5, 6 }, { 9, 8, 7 } };

// Function call
reverseColumnArray(arr);
}
}

// This code is contributed by 29AjayKumar```

## Python3

```# python implementation of the
# above approach
M = 3
N = 3

# Print the arr[][]

def printMatrix(arr):

for i in range(0, M):
for j in range(0, N):
print(arr[i][j], end=' ')

print()

# Function to reverse
# the given 2D arr[][]

def reverseColumnArray(arr):

# Print the arr[][] before
# reversing every column
printMatrix(arr)
print()

# Traverse each column of arr[][]
for i in range(0, N):
# Initialise start and end index
start = 0
end = M - 1

# Till start < end, swap the
# element at start and end index
while (start < end):
# Swap the element
temp = arr[start][i]
arr[start][i] = arr[end][i]
arr[end][i] = temp

# Increment start and decrement
# end for next pair of swapping
start += 1
end -= 1

# Print the arr[][] after
# reversing every column
printMatrix(arr)

# Driver Code
if __name__ == "__main__":

arr = [[3, 2, 1], [4, 5, 6], [9, 8, 7]]

# Function call
reverseColumnArray(arr)

# This code is contributed by rakeshsahni
```

## C#

```// C# implementation of the
// above approach
using System;
class GFG {

static int M = 3;
static int N = 3;

// A utility function
// for swapping two elements.
private static int[, ] swap(int[, ] arr, int start,
int i, int end, int j)
{

int temp = arr[start, i];
arr[start, i] = arr[end, j];
arr[end, j] = temp;
return arr;
}

// Print the arr[][]
static void printMatrix(int[, ] arr)
{

for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
Console.Write(arr[i, j] + " ");
}
Console.WriteLine("");
}
}

// Function to reverse
// the given 2D arr[][]
static void reverseColumnArray(int[, ] arr)
{

// Print the arr[][] before
// reversing every column
printMatrix(arr);
Console.WriteLine();

// Traverse each column of arr[][]
for (int i = 0; i < N; i++) {
// Initialise start and end index
int start = 0;
int end = M - 1;

// Till start < end, swap the
// element at start and end index
while (start < end) {

// Swap the element
arr = swap(arr, start, i, end, i);

// Increment start and decrement
// end for next pair of swapping
start++;
end--;
}
}

// Print the arr[][] after
// reversing every column
printMatrix(arr);
}

// Driver Code
public static void Main()
{
int[, ] arr
= { { 3, 2, 1 }, { 4, 5, 6 }, { 9, 8, 7 } };

// Function call
reverseColumnArray(arr);
}
}

// This code is contributed by Saurabh Jaiswal```

## Javascript

```<script>
// JavaScript code for the above approach
let M = 3;
let N = 3;

// Print the arr[][]
function printMatrix(arr) {

for (let i = 0; i < M; i++) {
for (let j = 0; j < N; j++) {
document.write(arr[i][j] + ' ');
}
document.write('<br>')
}
}

// Function to reverse
// the given 2D arr[][]
function reverseColumnArray(arr) {

// Print the arr[][] before
// reversing every column
printMatrix(arr);
document.write('<br>')

// Traverse each column of arr[][]
for (let i = 0; i < N; i++)
{

// Initialise start and end index
let start = 0;
let end = M - 1;

// Till start < end, swap the
// element at start and end index
while (start < end)
{

// Swap the element
let temp = arr[start][i]
arr[start][i] = arr[end][i]
arr[end][i] = temp

// Increment start and decrement
// end for next pair of swapping
start++;
end--;
}
}

// Print the arr[][] after
// reversing every column
printMatrix(arr);
}

// Driver Code
let arr
= [[3, 2, 1], [4, 5, 6], [9, 8, 7]];

// Function call
reverseColumnArray(arr);

// This code is contributed by Potta Lokesh
</script>```
Output

```3 2 1
4 5 6
9 8 7

9 8 7
4 5 6
3 2 1 ```

Time complexity: O(N2), two for loops are being used, one to iterate over all columns and the inner loop is swapping the start and end index of each column.
Auxiliary Space: O(1) as no extra space is used

My Personal Notes arrow_drop_up
Related Articles