Open In App

Program to reverse the rows in a 2d Array

Improve
Improve
Like Article
Like
Save
Share
Report

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.

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


Java




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();
        }
    }
}


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


C#




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();
        }
    }
}


Javascript




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


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.



Last Updated : 26 Oct, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads