Python Program to Sort the given matrix

Given a n x n matrix. The problem is to sort the given matrix in strict order. Here strict order means that matrix is sorted in a way such that all elements in a row are sorted in increasing order and for row ‘i’, where 1 <= i <= n-1, first element of row ‘i’ is greater than or equal to the last element of row ‘i-1’.
Examples: 

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

Approach: Create a temp[] array of size n^2. Starting with the first row one by one copy the elements of the given matrix into temp[]. Sort temp[]. Now one by one copy the elements of temp[] back to the given matrix.

Python3

# Python3 implementation to sort
# the given matrix

SIZE = 10

# Function to sort the given matrix
def sortMat(mat, n) :

    # Temporary matrix of size n^2
    temp = [0] * (n * n)
    k = 0

    # Copy the elements of matrix
    # one by one into temp[]
    for i in range(0, n) :

        for j in range(0, n) :

            temp[k] = mat[i][j]
            k += 1

    # sort temp[]
    temp.sort()

    # copy the elements of temp[]
    # one by one in mat[][]
    k = 0

    for i in range(0, n) :

        for j in range(0, n) :
            mat[i][j] = temp[k]
            k += 1


# Function to print the given matrix
def printMat(mat, n) :

    for i in range(0, n) :

        for j in range( 0, n ) :

            print(mat[i][j] , end = " ")

        print(" ")


# Driver program to test above
mat = [ [ 5, 4, 7 ],
        [ 1, 3, 8 ],
        [ 2, 9, 6 ] ]
n = 3

print( "Original Matrix:")
printMat(mat, n)

sortMat(mat, n)

print("Matrix After Sorting:")
printMat(mat, n)


# This code is contributed by Nikita Tiwari.

Output

Original Matrix:
5 4 7  
1 3 8  
2 9 6  
Matrix After Sorting:
1 2 3  
4 5 6  
7 8 9  

Time Complexity: O(n²log₂n). 
Auxiliary Space: O(n²).

To sort the matrix in the required strict order, we can use a different approach. One possibility is to flatten the matrix into a single list, sort the list, and then reshape the list into the original matrix shape.

Here is an example of how this can be done:

Python3

import numpy as np

mat = [[5, 4, 7],
       [1, 3, 8],
       [2, 9, 6]]

# flatten the matrix into a single list
flat_list = [item for sublist in mat for item in sublist]

# sort the list
flat_list.sort()

# reshape the list into the original matrix shape
mat = np.array(flat_list).reshape((3, 3))

# print the sorted matrix
for row in mat:
    print(row)

This will print the following matrix:

[1 2 3]
[4 5 6]
[7 8 9]

Time complexity: O(N * log N), where N is the number of elements in the matrix. 
 Auxiliary space: O(N), as it requires an additional list to store the flattened matrix.

Please refer complete article on Sort the given matrix for more details!

Approach#3: Using heapq

Another way to sort the matrix is to use a heap. We can create a min-heap and then extract the minimum element repeatedly to create a sorted list, which can then be reshaped back into a matrix.

Algorithm

1. Create a min-heap and insert all elements of the matrix into it.
2. Extract the minimum element from the heap repeatedly to create a sorted list.
3. Reshape the sorted list back into a matrix.

Python3

import heapq

def sort_matrix(mat):
    # Step 1: Create a min-heap and insert all elements of the matrix into it.
    heap = []
    for row in mat:
        for num in row:
            heapq.heappush(heap, num)

    # Step 2: Extract the minimum element from the heap repeatedly to create a sorted list.
    sorted_list = []
    while heap:
        sorted_list.append(heapq.heappop(heap))

    # Step 3: Reshape the sorted list back into a matrix.
    n_rows = len(mat)
    n_cols = len(mat[0])
    sorted_mat = [sorted_list[i:i+n_cols] for i in range(0, len(sorted_list), n_cols)]

    return sorted_mat

# Example usage:
mat = [[5, 4, 7], [1, 3, 8], [2, 9, 6]]
sorted_mat = sort_matrix(mat)
for row in sorted_mat:
    print(row)

Output

[1, 2, 3]
[4, 5, 6]
[7, 8, 9]

Time Complexity: O(n log n), where n is the total number of elements in the matrix. This is because inserting n elements into the heap takes O(n log n) time, and extracting n elements from the heap also takes O(n log n) time.

Space Complexity: O(n), where n is the total number