GeeksforGeeks App
Open App
Browser
Continue

# Program to reverse the rows in a 2d Array

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:

1. 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 ``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

 `// 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

 `# 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#

 `// 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`

## Javascript

 ``

Output:

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

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.

## Python3

 `# 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``()`

Output

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

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.

My Personal Notes arrow_drop_up