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

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

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

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.