# Print all elements in sorted order from row and column wise sorted matrix

• Difficulty Level : Medium
• Last Updated : 29 Jun, 2022

Given an n x n matrix, where every row and column is sorted in non-decreasing order. Print all elements of matrix in sorted order.

Example:

Input: mat[][] = { {10, 20, 30, 40},
{15, 25, 35, 45},
{27, 29, 37, 48},
{32, 33, 39, 50},
};
Output: 10 15 20 25 27 29 30 32 33 35 37 39 40 45 48 50

Recommended Practice

We can use Young Tableau to solve the above problem. The idea is to consider the given 2D array as Young Tableau and call extract minimum O(N)

## C++

 `// A C++ program to Print all elements in sorted order from row and``// column wise sorted matrix``#include``#include``using` `namespace` `std;` `#define INF INT_MAX``#define N 4` `// A utility function to youngify a Young Tableau.  This is different``// from standard youngify.  It assumes that the value at mat is``// infinite.``void` `youngify(``int` `mat[][N], ``int` `i, ``int` `j)``{``    ``// Find the values at down and right sides of mat[i][j]``    ``int` `downVal  = (i+1 < N)? mat[i+1][j]: INF;``    ``int` `rightVal = (j+1 < N)? mat[i][j+1]: INF;` `    ``// If mat[i][j] is the down right corner element, return``    ``if` `(downVal==INF && rightVal==INF)``        ``return``;` `    ``// Move the smaller of two values (downVal and rightVal) to``    ``// mat[i][j] and recur for smaller value``    ``if` `(downVal < rightVal)``    ``{``        ``mat[i][j] = downVal;``        ``mat[i+1][j] = INF;``        ``youngify(mat, i+1, j);``    ``}``    ``else``    ``{``        ``mat[i][j] = rightVal;``        ``mat[i][j+1] = INF;``        ``youngify(mat, i, j+1);``    ``}``}` `// A utility function to extract minimum element from Young tableau``int` `extractMin(``int` `mat[][N])``{``    ``int` `ret = mat;``    ``mat = INF;``    ``youngify(mat, 0, 0);``    ``return` `ret;``}` `// This function uses extractMin() to print elements in sorted order``void` `printSorted(``int` `mat[][N])``{``   ``for` `(``int` `i=0; i

## Java

 `// A Java program to Print all elements``// in sorted order from row and``// column wise sorted matrix``class` `GFG``{``    ``static` `final` `int` `INF = Integer.MAX_VALUE;``    ``static` `final` `int` `N = ``4``;` `    ``// A utility function to youngify a Young Tableau.``    ``// This is different from standard youngify.``    ``// It assumes that the value at mat is infinite.``    ``static` `void` `youngify(``int` `mat[][], ``int` `i, ``int` `j)``    ``{``        ``// Find the values at down and right sides of mat[i][j]``        ``int` `downVal = (i + ``1` `< N) ?``                    ``mat[i + ``1``][j] : INF;``        ``int` `rightVal = (j + ``1` `< N) ?``                     ``mat[i][j + ``1``] : INF;` `        ``// If mat[i][j] is the down right corner element,``        ``// return``        ``if` `(downVal == INF && rightVal == INF)``        ``{``            ``return``;``        ``}` `        ``// Move the smaller of two values``        ``// (downVal and rightVal) to mat[i][j]``        ``// and recur for smaller value``        ``if` `(downVal < rightVal)``        ``{``            ``mat[i][j] = downVal;``            ``mat[i + ``1``][j] = INF;``            ``youngify(mat, i + ``1``, j);``        ``}``        ``else``        ``{``            ``mat[i][j] = rightVal;``            ``mat[i][j + ``1``] = INF;``            ``youngify(mat, i, j + ``1``);``        ``}``    ``}` `    ``// A utility function to extract``    ``// minimum element from Young tableau``    ``static` `int` `extractMin(``int` `mat[][])``    ``{``        ``int` `ret = mat[``0``][``0``];``        ``mat[``0``][``0``] = INF;``        ``youngify(mat, ``0``, ``0``);``        ``return` `ret;``    ``}` `    ``// This function uses extractMin()``    ``// to print elements in sorted order``    ``static` `void` `printSorted(``int` `mat[][])``    ``{``        ``System.out.println(``"Elements of matrix in sorted order n"``);``        ``for` `(``int` `i = ``0``; i < N * N; i++)``        ``{``            ``System.out.print(extractMin(mat) + ``" "``);``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `mat[][] = {{``10``, ``20``, ``30``, ``40``},``                       ``{``15``, ``25``, ``35``, ``45``},``                       ``{``27``, ``29``, ``37``, ``48``},``                       ``{``32``, ``33``, ``39``, ``50``}};``        ``printSorted(mat);``    ``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python 3 program to Print all elements``# in sorted order from row and column``# wise sorted matrix``import` `sys` `INF ``=` `sys.maxsize``N ``=` `4` `# A utility function to youngify a Young``# Tableau. This is different from standard``# youngify. It assumes that the value at``# mat is infinite.``def` `youngify(mat, i, j):` `    ``# Find the values at down and``    ``# right sides of mat[i][j]``    ``downVal ``=` `mat[i ``+` `1``][j] ``if` `(i ``+` `1` `< N) ``else` `INF``    ``rightVal ``=` `mat[i][j ``+` `1``] ``if` `(j ``+` `1` `< N) ``else` `INF` `    ``# If mat[i][j] is the down right``    ``# corner element, return``    ``if` `(downVal ``=``=` `INF ``and` `rightVal ``=``=` `INF):``        ``return` `    ``# Move the smaller of two values``    ``# (downVal and rightVal) to mat[i][j]``    ``# and recur for smaller value``    ``if` `(downVal < rightVal):``        ``mat[i][j] ``=` `downVal``        ``mat[i ``+` `1``][j] ``=` `INF``        ``youngify(mat, i ``+` `1``, j)``    ` `    ``else``:``        ``mat[i][j] ``=` `rightVal``        ``mat[i][j ``+` `1``] ``=` `INF``        ``youngify(mat, i, j ``+` `1``)` `# A utility function to extract minimum``# element from Young tableau``def` `extractMin(mat):` `    ``ret ``=` `mat[``0``][``0``]``    ``mat[``0``][``0``] ``=` `INF``    ``youngify(mat, ``0``, ``0``)``    ``return` `ret` `# This function uses extractMin() to``# print elements in sorted order``def` `printSorted(mat):``        ` `    ``print``(``"Elements of matrix in sorted order n"``)``    ``i ``=` `0``    ``while` `i < N ``*` `N:``        ``print``(extractMin(mat), end ``=` `" "``)``        ``i ``+``=` `1` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ` `    ``mat ``=` `[[``10``, ``20``, ``30``, ``40``],``           ``[``15``, ``25``, ``35``, ``45``],``           ``[``27``, ``29``, ``37``, ``48``],``           ``[``32``, ``33``, ``39``, ``50``]]``    ``printSorted(mat)` `# This code is contributed by ita_c`

## C#

 `// A C# program to Print all elements``// in sorted order from row and``// column wise sorted matrix``using` `System;` `class` `GFG``{``    ``static` `int` `INF = ``int``.MaxValue;``    ``static` `int` `N = 4;` `    ``// A utility function to youngify a Young Tableau.``    ``// This is different from standard youngify.``    ``// It assumes that the value at mat is infinite.``    ``static` `void` `youngify(``int` `[,]mat, ``int` `i, ``int` `j)``    ``{``        ``// Find the values at down and right sides of mat[i][j]``        ``int` `downVal = (i + 1 < N) ?``                    ``mat[i + 1,j] : INF;``        ``int` `rightVal = (j + 1 < N) ?``                    ``mat[i,j + 1] : INF;` `        ``// If mat[i][j] is the down right corner element,``        ``// return``        ``if` `(downVal == INF && rightVal == INF)``        ``{``            ``return``;``        ``}` `        ``// Move the smaller of two values``        ``// (downVal and rightVal) to mat[i][j]``        ``// and recur for smaller value``        ``if` `(downVal < rightVal)``        ``{``            ``mat[i,j] = downVal;``            ``mat[i + 1,j] = INF;``            ``youngify(mat, i + 1, j);``        ``}``        ``else``        ``{``            ``mat[i, j] = rightVal;``            ``mat[i, j + 1] = INF;``            ``youngify(mat, i, j + 1);``        ``}``    ``}` `    ``// A utility function to extract``    ``// minimum element from Young tableau``    ``static` `int` `extractMin(``int` `[,]mat)``    ``{``        ``int` `ret = mat[0,0];``        ``mat[0, 0] = INF;``        ``youngify(mat, 0, 0);``        ``return` `ret;``    ``}` `    ``// This function uses extractMin()``    ``// to print elements in sorted order``    ``static` `void` `printSorted(``int` `[,]mat)``    ``{``            ``Console.WriteLine(``"Elements of matrix in sorted order n"``);``        ``for` `(``int` `i = 0; i < N * N; i++)``        ``{``            ``Console.Write(extractMin(mat) + ``" "``);``        ``}``    ``}` `    ``// Driver Code``    ``static` `public` `void` `Main ()``    ``{``        ``int` `[,]mat = {{10, 20, 30, 40},``                    ``{15, 25, 35, 45},``                    ``{27, 29, 37, 48},``                    ``{32, 33, 39, 50}};``        ``printSorted(mat);``    ``}``}` `// This code is contributed by ajit.`

## Javascript

 ``

Output

`10 15 20 25 27 29 30 32 33 35 37 39 40 45 48 50 `

Time complexity of extract minimum is O(N) and it is called O(N2) times. Therefore the overall time complexity is O(N3).

Another approach: The idea is to keep all elements of the matrix in a one-dimensional array and then sort the array and print all values in it.
Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `// Function to print all elements of matrix in sorted orderd``void` `sortedMatrix(``int` `N, vector > Mat)``{``    ``vector<``int``> temp;``  ` `   ``// Store all elements of matrix into temp``    ``for` `(``int` `i = 0; i < N; i++) {``        ``for` `(``int` `j = 0; j < N; j++) {``            ``temp.push_back(Mat[i][j]);``        ``}``    ``}` `    ``// Sort the temp``    ``sort(temp.begin(), temp.end());` `    ``// Print the values of temp``    ``for` `(``int` `i = 0; i < temp.size(); i++) {``        ``cout << temp[i] << ``" "``;``    ``}``}` `int` `main()``{``    ``int` `N = 4;``    ``vector > Mat = {``        ``{ 10, 20, 30, 40 },``        ``{ 15, 25, 35, 45 },``        ``{ 27, 29, 37, 48 },``        ``{ 32, 33, 39, 50 },``    ``};``    ``sortedMatrix(N, Mat);` `    ``return` `0;``}` `// This code is contributed by pratiknawale999`

## Java

 `// A Java program to Print all elements``// in sorted order from row and``// column wise sorted matrix``import` `java.io.*;``import` `java.util.*;` `class` `GFG {` `  ``// Function to print all elements of matrix in sorted orderd``  ``static` `void` `sortedMatrix(``int` `N, ``int``[][] mat)``  ``{``    ``List temp = ``new` `ArrayList();` `    ``// Store all elements of matrix into temp``    ``for` `(``int` `i = ``0``; i < N; i++) {``      ``for` `(``int` `j = ``0``; j < N; j++) {``        ``temp.add(mat[i][j]);``      ``}``    ``}` `    ``// Sort the temp``    ``Collections.sort(temp);` `    ``// Print the values of temp``    ``for` `(``int` `i = ``0``; i < temp.size(); i++) {``      ``System.out.print(temp.get(i)+``" "``);``    ``}``  ``}` `  ``public` `static` `void` `main (String[] args) {``    ``int` `N = ``4``;``    ``int` `mat[][] = {{``10``, ``20``, ``30``, ``40``},``                   ``{``15``, ``25``, ``35``, ``45``},``                   ``{``27``, ``29``, ``37``, ``48``},``                   ``{``32``, ``33``, ``39``, ``50``}};``    ``sortedMatrix(N,mat);``  ``}``}` `// This code is contributed by shruti456rawal`

## Python3

 `# Function to print all elements of matrix in sorted orderd``def` `sortedMatrix(N, Mat):``    ``temp ``=` `[]` `    ``# Store all elements of matrix into temp``    ``for` `i ``in` `range``(``0``, N):``        ``for` `j ``in` `range``(``0``, N):``            ``temp.append(Mat[i][j])` `    ``# Sort the temp``    ``temp.sort()` `    ``# Print the values of temp``    ``for` `i ``in` `range``(``len``(temp)):``        ``print``(temp[i], end``=``' '``)`  `if` `__name__ ``=``=` `"__main__"``:``    ``N ``=` `4``    ``Mat ``=` `[[``10``, ``20``, ``30``, ``40``], [``15``, ``25``, ``35``, ``45``],``           ``[``27``, ``29``, ``37``, ``48``], [``32``, ``33``, ``39``, ``50``]]``    ``sortedMatrix(N, ``list``(Mat))` `# This code is contributed by Aarti_Rathi`

## C#

 `using` `System;``using` `System.Collections.Generic;` `public` `static` `class` `GFG {` `    ``// Function to print all elements of matrix in sorted``    ``// orderd``    ``static` `void` `sortedMatrix(``int` `N, List > Mat)``    ``{``        ``List<``int``> temp = ``new` `List<``int``>();` `        ``// Store all elements of matrix into temp``        ``for` `(``int` `i = 0; i < N; i++) {``            ``for` `(``int` `j = 0; j < N; j++) {``                ``temp.Add(Mat[i][j]);``            ``}``        ``}` `        ``// Sort the temp``        ``temp.Sort();` `        ``// Print the values of temp``        ``for` `(``int` `i = 0; i < temp.Count; i++) {``            ``Console.Write(temp[i]);``            ``Console.Write(``" "``);``        ``}``    ``}` `    ``public` `static` `void` `Main()``    ``{``        ``int` `N = 4;``        ``List > Mat = ``new` `List >() {``            ``new` `List<``int``>{ 10, 20, 30, 40 },``                ``new` `List<``int``>{ 15, 25, 35, 45 },``                ``new` `List<``int``>{ 27, 29, 37, 48 },``                ``new` `List<``int``>``            ``{``                ``32, 33, 39, 50``            ``}``        ``};``        ``sortedMatrix(N, ``new` `List >(Mat));``    ``}` `    ``// This code is contributed by Aarti_Rathi``}`

## Javascript

 `// A JavaScript program to Print all elements``// in sorted order from row and``// column wise sorted matrix` `// Function to print all elements of matrix in sorted orderd``function` `sortedMatrix(N, mat)``{``    ``var` `temp = [];``    ``// Store all elements of matrix into temp``    ``for` `(``var` `i=0; i < N; i++)``    ``{``        ``for` `(``var` `j=0; j < N; j++)``        ``{``            ``(temp.push(mat[i][j]));``        ``}``    ``}``    ``// Sort the temp``    ``temp.sort();``    ``// Print the values of temp``    ``for` `(``var` `i =0; i < temp.length; i++)``    ``{``        ``console.log(temp[i] + ``" "``);``    ``}``}``    ` `var` `N = 4;``var` `mat = [[10, 20, 30, 40], [15, 25, 35, 45], [27, 29, 37, 48], [32, 33, 39, 50]];``sortedMatrix(N, mat);` `// This code is contributed by Aarti_Rathi`

Output

`10 15 20 25 27 29 30 32 33 35 37 39 40 45 48 50 `

Time Complexity: O(N2log(N2))
Auxiliary Space: O(N2)

A better solution is to use the approach used for merging k sorted arrays. The idea is to use a Min Heap of size N which stores elements of first column. They do extract minimum. In extract minimum, replace the minimum element with the next element of the row from which the element is extracted.

## C++

 `// C++ program to merge k sorted arrays of size n each.``#include``#include``using` `namespace` `std;` `#define N 4` `// A min heap node``struct` `MinHeapNode``{``    ``int` `element; ``// The element to be stored``    ``int` `i; ``// index of the row from which the element is taken``    ``int` `j; ``// index of the next element to be picked from row``};` `// Prototype of a utility function to swap two min heap nodes``void` `swap(MinHeapNode *x, MinHeapNode *y);` `// A class for Min Heap``class` `MinHeap``{``    ``MinHeapNode *harr; ``// pointer to array of elements in heap``    ``int` `heap_size; ``// size of min heap``public``:``    ``// Constructor: creates a min heap of given size``    ``MinHeap(MinHeapNode a[], ``int` `size);` `    ``// to heapify a subtree with root at given index``    ``void` `MinHeapify(``int` `);` `    ``// to get index of left child of node at index i``    ``int` `left(``int` `i) { ``return` `(2*i + 1); }` `    ``// to get index of right child of node at index i``    ``int` `right(``int` `i) { ``return` `(2*i + 2); }` `    ``// to get the root``    ``MinHeapNode getMin() { ``return` `harr; }` `    ``// to replace root with new node x and heapify() new root``    ``void` `replaceMin(MinHeapNode x) { harr = x;  MinHeapify(0); }``};` `// This function prints elements of a given matrix in non-decreasing``//  order. It assumes that ma[][] is sorted row wise sorted.``void` `printSorted(``int` `mat[][N])``{``    ``// Create a min heap with k heap nodes.  Every heap node``    ``// has first element of an array``    ``MinHeapNode *harr = ``new` `MinHeapNode[N];``    ``for` `(``int` `i = 0; i < N; i++)``    ``{``        ``harr[i].element = mat[i]; ``// Store the first element``        ``harr[i].i = i;  ``// index of row``        ``harr[i].j = 1;  ``// Index of next element to be stored from row``    ``}``    ``MinHeap hp(harr, N); ``// Create the min heap` `    ``// Now one by one get the minimum element from min``    ``// heap and replace it with next element of its array``    ``for` `(``int` `count = 0; count < N*N; count++)``    ``{``        ``// Get the minimum element and store it in output``        ``MinHeapNode root = hp.getMin();` `        ``cout << root.element << ``" "``;` `        ``// Find the next element that will replace current``        ``// root of heap. The next element belongs to same``        ``// array as the current root.``        ``if` `(root.j < N)``        ``{``            ``root.element = mat[root.i][root.j];``            ``root.j += 1;``        ``}``        ``// If root was the last element of its array``        ``else` `root.element =  INT_MAX; ``//INT_MAX is for infinite` `        ``// Replace root with next element of array``        ``hp.replaceMin(root);``    ``}``}` `// FOLLOWING ARE IMPLEMENTATIONS OF STANDARD MIN HEAP METHODS``// FROM CORMEN BOOK``// Constructor: Builds a heap from a given array a[] of given size``MinHeap::MinHeap(MinHeapNode a[], ``int` `size)``{``    ``heap_size = size;``    ``harr = a;  ``// store address of array``    ``int` `i = (heap_size - 1)/2;``    ``while` `(i >= 0)``    ``{``        ``MinHeapify(i);``        ``i--;``    ``}``}` `// A recursive method to heapify a subtree with root at given index``// This method assumes that the subtrees are already heapified``void` `MinHeap::MinHeapify(``int` `i)``{``    ``int` `l = left(i);``    ``int` `r = right(i);``    ``int` `smallest = i;``    ``if` `(l < heap_size && harr[l].element < harr[i].element)``        ``smallest = l;``    ``if` `(r < heap_size && harr[r].element < harr[smallest].element)``        ``smallest = r;``    ``if` `(smallest != i)``    ``{``        ``swap(&harr[i], &harr[smallest]);``        ``MinHeapify(smallest);``    ``}``}` `// A utility function to swap two elements``void` `swap(MinHeapNode *x, MinHeapNode *y)``{``    ``MinHeapNode temp = *x;  *x = *y;  *y = temp;``}` `// driver program to test above function``int` `main()``{``  ``int` `mat[N][N] = { {10, 20, 30, 40},``                    ``{15, 25, 35, 45},``                    ``{27, 29, 37, 48},``                    ``{32, 33, 39, 50},``                  ``};``  ``printSorted(mat);``  ``return` `0;``}`

Output

`10 15 20 25 27 29 30 32 33 35 37 39 40 45 48 50 `

Time complexity: O(N2LogN).

Exercise:
Above solutions work for a square matrix. Extend the above solutions to work for an M*N rectangular matrix.