Sort the given Matrix In-Place

Given a matrix of m rows and n 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.

Input : mat[][] = { {5, 4, 7},
{1, 3, 8},
{2, 9, 6} }
Output : 1 2 3
4 5 6
7 8 9

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

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:

Consider a 2*2 Matrix with 4 elements. The idea is to treat the elements of the matrix as 1D Array of 4 elements.
As In the given matrix each element can be accessed as -
1^st Element - 0^th Row, 0^th Col
2^nd Element - 0^th Row, 1^st Col
3^rd Element - 1^st Row, 0^th Col
4^th Element - 1^st Row, 1^st Col

So, for Accessing i^th element of the matrix, the relation can be defined as:

I^th Element of the Matrix = Mat[ i / n ][ i % n ]  

Where n is the number of columns

• Find the number of rows(say m) and columns(say n) 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 the number of elements (m * n).
• Find the appropriate position of the element in the matrix using the above formulae for each element.
• Compare each element with the next element (For the last element in the row, the next element will be the next row first element) in the matrix, and if the next element is, less then swap these elements.

Below is the implementation of the above approach: 

1 2 3 
4 5 6 
7 8 9

Illustration with Example:

Performance Analysis:

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