Skip to content
Related Articles

Related Articles

Sort the given Matrix | Memory Efficient Approach
  • Last Updated : 27 Jul, 2020

Given a matrix of N rows and M columns, the task is to sort the matrix in the strict order that is every row is sorted in increasing order and the first element of every row is greater than the first element of the previous row.

Examples:

Input: M[][] = { {5, 4, 7}, 
                 {1, 3, 8}, 
                 {2, 9, 6} }
Output: 1 2 3
        4 5 6
        7 8 9
Explanation:
Please refer above image

Input: M[][] = { {5, 4, 7},
                 {1, 3, 8} }
Output: 1 3 4
        5 7 8

Approach: The idea is to treat the 2D-Array as a 1D-Array to sort the matrix without using extra space. This can also be explained with the help of the following example
For Example:

There is a 2*2 Matrix with 4 elements,
The idea is to treat the elements of the matrix
as 1D Array of 4 elements.

1 2
3 4

As In the given matrix each element can be accessed as -
1st Element - 0th Row, 0th Col
2nd Element - 0th Row, 1st Col
3rd Element - 1st Row, 0th Col
4th Element - 1st Row, 1st Col 

So For Accessing ith element of the matrix, the relation which can be defined as –



Ith Element of the Matrix = Mat[ i / cols ][ i % cols ]

Algorithm:

  • Find the number of rows(say rows) and columns(say cols) in the matrix by finding the length of the number of rows in the 2D-Array and the elements in each row in the Array.
  • Iterate over each element of the matrix from 0 to number of elements (rows * cols).
  • Find the approprite position of the element in the matrix using above formulae for each element.
  • Compare each element with the next element (For the last element in the row, next element will be next row first element) in the matrix and if the next element is the less then swap these elements.

Illustration with Example:

IJComparison ElementsMatrixComments
00(0, 0) & (0, 1)5 6 7
1 4 8
No Swap
01(0, 1) & (0, 2)5 6 7
1 4 8
No Swap
02(0, 2) & (1, 0)5 6 1
7 4 8
Swapped
03(1, 0) & (1, 1)5 6 1
4 7 8
Swapped
04(1, 1) & (1, 2)5 6 1
4 7 8
No Swap
10(0, 0) & (0, 1)5 6 1
4 7 8
No Swap
11(0, 1) & (0, 2)5 1 6
4 7 8
Swapped
12(0, 2) & (1, 0)5 1 4
6 7 8
Swapped
13(1, 0) & (1, 1)5 1 4
6 7 8
No Swap
14(1, 1) & (1, 2)5 1 4
4 7 8
No Swap
20(0, 0) & (0, 1)1 5 4
6 7 8
Swapped
21(0, 1) & (0, 2)1 4 5
6 7 8
Swapped
22(0, 2) & (1, 0)1 4 5
6 7 8
No Swap
23(1, 0) & (1, 1)5 1 4
6 7 8
No Swap
24(1, 1) & (1, 2)5 1 4
4 7 8
No Swap

Below is the implementation of the above approach:

C++




// C++ implementation to sort
// the given matrix in strict order 
#include <bits/stdc++.h> 
using namespace std; 
#define N 3 
#define M 3 
  
// Function to sort the matrix
void sortMat(int data[N][M], int row, int col)
{
  
    // Number of elements in matrix
    int size = row * col;
  
    // Loop to sort the matrix
    // using Bubble Sort
    for (int i = 0; i < size; i++)
    {
        for (int j = 0; j < size - 1; j++) 
        {
  
            // Condition to check
            // if the Adjacent elements
            if (data[j / col][j % col] > data[(j + 1) 
                / col][(j + 1) % col])
            {
  
                // Swap if previous value is greater
                int temp = data[j / col][j % col];
                data[j / col][j % col] = data[(j + 1) 
                    / col][(j + 1) % col];
                data[(j + 1) / col][(j + 1) % col] = temp;
            }
        }
    }
}
  
void printMat(int mat[N][M], int row, int col)
{
  
    // Loop to print the matrix
    for (int i = 0; i < row; i++) 
    {
        for (int j = 0; j < col; j++)
        {
            cout << mat[i][j] << " ";
        }
        cout << endl;
    }
}
  
// Driver Code 
int main() 
    int mat[N][M] = { { 5, 4, 7 }, 
                        { 1, 3, 8 },
                        { 2, 9, 6 } };
          
    int row = N;
    int col = M;
  
    // Function call to sort
    sortMat(mat, row, col);
  
    // Function call to
    // print matrix
    printMat(mat, row, col);
    return 0; 
  
// This code is contributed by 29AjayKumar

Java




// Java implementation to sort
// the given matrix in strict order
class GFG 
{
    // Function to sort the matrix
    static void sortMat(int[][] data, int row, int col)
    {
  
        // Number of elements in matrix
        int size = row * col;
  
        // Loop to sort the matrix
        // using Bubble Sort
        for (int i = 0; i < size; i++)
        {
            for (int j = 0; j < size - 1; j++) 
            {
  
                // Condition to check
                // if the Adjacent elements
                if (data[j / col][j % col] > data[(j + 1
                    / col][(j + 1) % col])
                {
  
                    // Swap if previous value is greater
                    int temp = data[j / col][j % col];
                    data[j / col][j % col] = data[(j + 1
                        / col][(j + 1) % col];
                    data[(j + 1) / col][(j + 1) % col] = temp;
                }
            }
        }
    }
  
    static void printMat(int[][] mat, int row, int col)
    {
  
        // Loop to print the matrix
        for (int i = 0; i < row; i++) 
        {
            for (int j = 0; j < col; j++)
            {
                System.out.print(mat[i][j] + " ");
            }
            System.out.println();
        }
    }
  
    // Driver Code
    public static void main(String[] args)
    {
          
        int[][] mat = { { 5, 4, 7 }, 
                        { 1, 3, 8 },
                        { 2, 9, 6 } };
          
        int row = mat.length;
        int col = mat[0].length;
  
        // Function call to sort
        sortMat(mat, row, col);
  
        // Function call to
        // print matrix
        printMat(mat, row, col);
    }
}
  
// This code is contributed by PrinciRaj1992

Python3




# Python3 implementation to sort
# the given matrix in strict order
  
# Function to sort the matrix
def sortMat(data, row, col):
      
    # Number of elements in matrix
    size = row * col
      
    # Loop to sort the matrix 
    # using Bubble Sort
    for i in range(0, size):
        for j in range(0, size-1):
              
            # Condition to check
            # if the Adjacent elements
            if ( data[j//col][j % col] >\
                data[(j + 1)//col][(j + 1)% col] ):
                  
                # Swap if previous value is greater
                temp = data[j//col][j % col]
                data[j//col][j % col] =\
                    data[(j + 1)//col][(j + 1)% col]
                data[(j + 1)//col][(j + 1)% col] =\
                                 temp
  
def printMat(mat, row, col):
      
    # Loop to print the matrix
    for i in range(row):
        for j in range(col):
            print(mat[i][j], end =" ")
        print()
  
# Driver Code
if __name__ == "__main__":
    mat = [ [5, 4, 7],
            [1, 3, 8],
            [2, 9, 6] ]
    row = len(mat) 
    col = len(mat[0])
      
    # Function call to sort
    sortMat(mat, row, col)
      
    # Function call to
    # print matrix
    printMat(mat, row, col)

C#




// C# implementation to sort
// the given matrix in strict order
using System;
  
class GFG 
{
    // Function to sort the matrix
    static void sortMat(int[,] data, int row, int col)
    {
   
        // Number of elements in matrix
        int size = row * col;
   
        // Loop to sort the matrix
        // using Bubble Sort
        for (int i = 0; i < size; i++)
        {
            for (int j = 0; j < size - 1; j++) 
            {
   
                // Condition to check
                // if the Adjacent elements
                if (data[j / col,j % col] > data[(j + 1) 
                    / col,(j + 1) % col])
                {
   
                    // Swap if previous value is greater
                    int temp = data[j / col,j % col];
                    data[j / col,j % col] = data[(j + 1) 
                        / col,(j + 1) % col];
                    data[(j + 1) / col,(j + 1) % col] = temp;
                }
            }
        }
    }
   
    static void printMat(int[,] mat, int row, int col)
    {
   
        // Loop to print the matrix
        for (int i = 0; i < row; i++) 
        {
            for (int j = 0; j < col; j++)
            {
                Console.Write(mat[i,j] + " ");
            }
            Console.WriteLine();
        }
    }
   
    // Driver Code
    public static void Main(String[] args)
    {
           
        int[,] mat = { { 5, 4, 7 }, 
                        { 1, 3, 8 },
                        { 2, 9, 6 } };
           
        int row = mat.GetLength(0);
        int col = mat.GetLength(1);
   
        // Function call to sort
        sortMat(mat, row, col);
   
        // Function call to
        // print matrix
        printMat(mat, row, col);
    }
}
  
// This code is contributed by 29AjayKumar
Output:
1 2 3 
4 5 6 
7 8 9

Performance Analysis:

  • Time Complexity: In the given approach, we are sorting the elements in the matrix by considering the elements in 1D-Array using Bubble sort, So the overall complexity will be O(N * M>)
  • Space Complexity: In the given approach no extra space is used, So the overall space complexity will be O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :