# Kth smallest element in a row-wise and column-wise sorted 2D array

• Difficulty Level : Hard
• Last Updated : 14 Mar, 2023

Given an n x n matrix, where every row and column is sorted in non-decreasing order. Find the kth smallest element in the given 2D array.

Example,

```Input:k = 3 and array =
10, 20, 30, 40
15, 25, 35, 45
24, 29, 37, 48
32, 33, 39, 50
Output: 20
Explanation: The 3rd smallest element is 20

Input:k = 7 and array =
10, 20, 30, 40
15, 25, 35, 45
24, 29, 37, 48
32, 33, 39, 50
Output: 30

Explanation: The 7th smallest element is 30```
Recommended Practice

Approach: So the idea is to find the kth minimum element. Each row and each column is sorted. So it can be thought as C sorted lists and the lists have to be merged into a single list, the kth element of the list has to be found out. So the approach is similar, the only difference is when the kth element is found the loop ends.
Algorithm:

1. The idea is to use min heap. Create a Min-Heap to store the elements
2. Traverse the first row from start to end and build a min heap of elements from first row. A heap entry also stores row number and column number.
3. Now Run a loop k times to extract min element from heap in each iteration
4. Get minimum element (or root) from Min-Heap.
5. Find row number and column number of the minimum element.
6. Replace root with the next element from same column and min-heapify the root.
7. Print the last extracted element, which is the kth minimum element

Implementation:

## C++

 `// kth largest element in a 2d array sorted row-wise and``// column-wise``#include ``using` `namespace` `std;` `// A structure to store entry of heap. The entry contains``// value from 2D array, row and column numbers of the value``struct` `HeapNode {``    ``int` `val; ``// value to be stored``    ``int` `r; ``// Row number of value in 2D array``    ``int` `c; ``// Column number of value in 2D array``};` `// A utility function to minheapify the node harr[i] of a``// heap stored in harr[]``void` `minHeapify(HeapNode harr[], ``int` `i, ``int` `heap_size)``{``    ``int` `l = i * 2 + 1;``    ``int` `r = i * 2 + 2;``     ``if``(l < heap_size&& r= n * n)``        ``return` `INT_MAX;` `    ``// Create a min heap of elements from first row of 2D``    ``// array``    ``HeapNode harr[n];``    ``for` `(``int` `i = 0; i < n; i++)``        ``harr[i] = { mat[0][i], 0, i };` `    ``HeapNode hr;``    ``for` `(``int` `i = 0; i < k; i++) {``        ``// Get current heap root``        ``hr = harr[0];` `        ``// Get next value from column of root's value. If``        ``// the value stored at root was last value in its``        ``// column, then assign INFINITE as next value``        ``int` `nextval = (hr.r < (n - 1)) ? mat[hr.r + 1][hr.c]: INT_MAX;` `        ``// Update heap root with next value``        ``harr[0] = { nextval, (hr.r) + 1, hr.c };` `        ``// Heapify root``        ``minHeapify(harr, 0, n);``    ``}` `    ``// Return the value at last extracted root``    ``return` `hr.val;``}` `// driver program to test above function``int` `main()``{``    ``int` `mat[4][4] = {``        ``{ 10, 20, 30, 40 },``        ``{ 15, 25, 35, 45 },``        ``{ 25, 29, 37, 48 },``        ``{ 32, 33, 39, 50 },``    ``};``    ``cout << ``"7th smallest element is "``        ``<< kthSmallest(mat, 4, 7);``    ``return` `0;``}` `// this code is contributed by Rishabh Chauhan`

## Java

 `// Java program for kth largest element in a 2d``// array sorted row-wise and column-wise``import` `java.io.*;` `public` `class` `GFG{``    ` `// A structure to store entry of heap.``// The entry contains value from 2D array,``// row and column numbers of the value``static` `class` `HeapNode``{``    ` `    ``// Value to be stored``    ``int` `val;``    ` `    ``// Row number of value in 2D array``    ``int` `r;``    ` `    ``// Column number of value in 2D array``    ``int` `c;``    ` `    ``HeapNode(``int` `val, ``int` `r, ``int` `c)``    ``{``        ``this``.val = val;``        ``this``.c = c;``        ``this``.r = r;``    ``}``}` `// A utility function to minheapify the node``// harr[i] of a heap stored in harr[]``static` `void` `minHeapify(HeapNode harr[],``                       ``int` `i, ``int` `heap_size)``{``    ``int` `l = ``2` `* i + ``1``;``    ``int` `r = ``2` `* i + ``2``;``    ``int` `min = i;``    ` `    ``if``(l < heap_size&& r= n * n)``        ``return` `Integer.MAX_VALUE;``    ` `    ``// Create a min heap of elements``    ``// from first row of 2D array``    ``HeapNode harr[] = ``new` `HeapNode[n];``    ` `    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ``harr[i] = ``new` `HeapNode(mat[``0``][i], ``0``, i);``    ``}``    ` `    ``HeapNode hr = ``new` `HeapNode(``0``, ``0``, ``0``);``    ` `    ``for``(``int` `i = ``1``; i <= k; i++)``    ``{``        ` `        ``// Get current heap root``        ``hr = harr[``0``];``        ` `        ``// Get next value from column of root's``        ``// value. If the value stored at root was``        ``// last value in its column, then assign``        ``// INFINITE as next value``        ``int` `nextVal = hr.r < n - ``1` `?``                      ``mat[hr.r + ``1``][hr.c] :``                      ``Integer.MAX_VALUE;``                      ` `        ``// Update heap root with next value``        ``harr[``0``] = ``new` `HeapNode(nextVal,``                               ``hr.r + ``1``, hr.c);``                               ` `        ``// Heapify root``        ``minHeapify(harr, ``0``, n);``    ``}``    ` `    ``// Return the value at last extracted root``    ``return` `hr.val;``}` `// Driver code``public` `static` `void` `main(String args[])``{``    ``int` `mat[][] = { { ``10``, ``20``, ``30``, ``40` `},``                    ``{ ``15``, ``25``, ``35``, ``45` `},``                    ``{ ``25``, ``29``, ``37``, ``48` `},``                    ``{ ``32``, ``33``, ``39``, ``50` `} };``                    ` `    ``int` `res = kthSmallest(mat, ``4``, ``7``);``    ` `    ``System.out.print(``"7th smallest element is "``+ res);``}``}` `// This code is contributed by Rishabh Chauhan`

## Python3

 `# Program for kth largest element in a 2d array``# sorted row-wise and column-wise``from` `sys ``import` `maxsize` `# A structure to store an entry of heap.``# The entry contains a value from 2D array,``# row and column numbers of the value``class` `HeapNode:``    ``def` `__init__(``self``, val, r, c):``        ``self``.val ``=` `val ``# value to be stored``        ``self``.r ``=` `r ``# Row number of value in 2D array``        ``self``.c ``=` `c ``# Column number of value in 2D array` `# A utility function to minheapify the node harr[i]``# of a heap stored in harr[]``def` `minHeapify(harr, i, heap_size):``    ``l ``=` `i ``*` `2` `+` `1``    ``r ``=` `i ``*` `2` `+` `2``    ``if``(l < heap_size ``and` `r n ``*` `n:``        ``return` `maxsize` `    ``# Create a min heap of elements from``    ``# first row of 2D array``    ``harr ``=` `[``0``] ``*` `n``    ``for` `i ``in` `range``(n):``        ``harr[i] ``=` `HeapNode(mat[``0``][i], ``0``, i)` `    ``hr ``=` `HeapNode(``0``, ``0``, ``0``)``    ``for` `i ``in` `range``(k):` `        ``# Get current heap root``        ``hr ``=` `harr[``0``]` `        ``# Get next value from column of root's value.``        ``# If the value stored at root was last value``        ``# in its column, then assign INFINITE as next value``        ``nextval ``=` `mat[hr.r ``+` `1``][hr.c] ``if` `(hr.r < n ``-` `1``) ``else` `maxsize` `        ``# Update heap root with next value``        ``harr[``0``] ``=` `HeapNode(nextval, hr.r ``+` `1``, hr.c)` `        ``# Heapify root``        ``minHeapify(harr, ``0``, n)` `    ``# Return the value at last extracted root``    ``return` `hr.val` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ``mat ``=` `[[``10``, ``20``, ``30``, ``40``],``        ``[``15``, ``25``, ``35``, ``45``],``        ``[``25``, ``29``, ``37``, ``48``],``        ``[``32``, ``33``, ``39``, ``50``]]``    ``print``(``"7th smallest element is"``,``            ``kthSmallest(mat, ``4``, ``7``))` `# This code is contributed by Rishabh Chauhan`

## C#

 `// C# program for kth largest element in a 2d``// array sorted row-wise and column-wise``using` `System;` `class` `GFG{``    ` `// A structure to store entry of heap.``// The entry contains value from 2D array,``// row and column numbers of the value``class` `HeapNode``{``    ` `    ``// Value to be stored``    ``public` `int` `val;``    ` `    ``// Row number of value in 2D array``    ``public` `int` `r;``    ` `    ``// Column number of value in 2D array``    ``public` `int` `c;``    ` `    ``public` `HeapNode(``int` `val, ``int` `r, ``int` `c)``    ``{``        ``this``.val = val;``        ``this``.c = c;``        ``this``.r = r;``    ``}``}` `// A utility function to minheapify the node``// harr[i] of a heap stored in harr[]``static` `void` `minHeapify(HeapNode []harr, ``int` `i, ``int` `heap_size){``    ``int` `l = 2 * i + 1;``    ``int` `r = 2 * i + 2;``  ` `    ``if``(l < heap_size && r < heap_size && harr[l].val < harr[i].val && harr[r].val < harr[i].val){``            ``HeapNode temp = ``new` `HeapNode(0, 0, 0);``            ``temp=harr[r];``            ``harr[r]=harr[i];``            ``harr[i]=harr[l];``            ``harr[l]=temp;``            ``minHeapify(harr ,l,heap_size);``            ``minHeapify(harr ,r,heap_size);``        ``}``          ``if` `(l < heap_size && harr[l].val < harr[i].val){``            ``HeapNode temp = ``new` `HeapNode(0, 0, 0);   ``            ``temp = harr[i];``            ``harr[i]=harr[l];``            ``harr[l]=temp;``            ``minHeapify(harr ,l,heap_size);``        ``}``}` `// This function returns kth smallest``// element in a 2D array [,]mat``public` `static` `int` `kthSmallest(``int``[,] mat,``int` `n, ``int` `k)``{``    ` `    ``// k must be greater than 0 and``    ``// smaller than n*n``    ``if` `(k < 0 || k > n * n)``    ``{``        ``return` `int``.MaxValue;``    ``}``    ` `    ``// Create a min heap of elements``    ``// from first row of 2D array``    ``HeapNode []harr = ``new` `HeapNode[n];``    ` `    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``harr[i] = ``new` `HeapNode(mat[0, i], 0, i);``    ``}``    ` `    ``HeapNode hr = ``new` `HeapNode(0, 0, 0);``    ` `    ``for``(``int` `i = 0; i < k; i++)``    ``{``        ` `        ``// Get current heap root``        ``hr = harr[0];``        ` `        ``// Get next value from column of root's``        ``// value. If the value stored at root was``        ``// last value in its column, then assign``        ``// INFINITE as next value``        ``int` `nextVal = hr.r < n - 1 ?``                      ``mat[hr.r + 1, hr.c] :``                      ``int``.MaxValue;``                      ` `        ``// Update heap root with next value``        ``harr[0] = ``new` `HeapNode(nextVal, hr.r + 1, hr.c);``                               ` `        ``// Heapify root``        ``minHeapify(harr, 0, n);``    ``}``    ` `    ``// Return the value at last``    ``// extracted root``    ``return` `hr.val;``}` `// Driver code``public` `static` `void` `Main(String []args)``{``    ``int` `[,]mat = { { 10, 20, 30, 40 },``                   ``{ 15, 25, 35, 45 },``                   ``{ 25, 29, 37, 48 },``                   ``{ 32, 33, 39, 50 } };``                    ` `    ``int` `res = kthSmallest(mat, 4, 7);``    ` `    ``Console.Write(``"7th smallest element is "` `+ res);``}``}` `// This code is contributed by Rishabh Chauhan`

## Javascript

 ``

Output

`7th smallest element is 30`

The codes above are contributed by RISHABH CHAUHAN.
Complexity Analysis:

• Time Complexity: The above solution involves following steps.
1. Building a min-heap which takes O(n) time
2. Heapify k times which takes O(k Logn) time.
• Auxiliary Space: O(R), where R is the length of a row, as the Min-Heap stores one row at a time.

The above code can be optimized to build a heap of size k when k is smaller than n. In that case, the kth smallest element must be in first k rows and k columns.
We will soon be publishing more efficient algorithms for finding the kth smallest element.

Using inbuilt priority_queue :

By using a comparator, we can carry out custom comparison in priority_queue. We will use priority_queue<pair<int,int>> for this.

Implementation :

## C++

 `// kth largest element in a 2d array sorted row-wise and``// column-wise``#include``using` `namespace` `std;` `int` `kthSmallest(``int` `mat[4][4], ``int` `n, ``int` `k)``{``    ``// USING LAMBDA FUNCTION``    ``// [=] IN LAMBDA FUNCTION IS FOR CAPTURING VARIABLES WHICH``    ``// ARE OUT OF SCOPE i.e. mat[r]``    ``// NOW, IT'LL COMPARE ELEMENTS OF HEAP BY ELEMENTS AT mat[first][second]``      ``// Capturing the value of mat by reference to prevent copying``    ``auto` `cmp = [&](pair<``int``,``int``> a,pair<``int``,``int``> b){``        ``return` `mat[a.first][a.second] > mat[b.first][b.second];``    ``};``    ` `    ``//DECLARING priority_queue AND PUSHING FIRST ROW IN IT``    ``priority_queue,vector>,``decltype``(cmp)> pq(cmp);``    ``for``(``int` `i=0; i

## Java

 `// kth largest element in a 2d array sorted row-wise and``// column-wise``import` `java.util.*;` `public` `class` `GFG {` `  ``static` `class` `pair {``    ``int` `first, second;``    ``pair(``int` `f, ``int` `s)``    ``{``      ``first = f;``      ``second = s;``    ``}``  ``}``  ``static` `int` `kthSmallest(``int` `mat[][], ``int` `n, ``int` `k)``  ``{``    ``// USING LAMBDA FUNCTION``    ``// [=] IN LAMBDA FUNCTION IS FOR CAPTURING VARIABLES``    ``// WHICH ARE OUT OF SCOPE i.e. mat[r] NOW, IT'LL``    ``// COMPARE ELEMENTS OF HEAP BY ELEMENTS AT``    ``// mat[first][second] Capturing the value of mat by``    ``// reference to prevent copying` `    ``// DECLARING priority_queue AND PUSHING FIRST ROW IN``    ``// IT``    ``PriorityQueue pq``      ``= ``new` `PriorityQueue<>((pair a, pair b) -> {``        ``return` `mat[a.first][a.second]``          ``- mat[b.first][b.second];``      ``});` `    ``for` `(``int` `i = ``0``; i < n; i++) {``      ``pq.add(``new` `pair(i, ``0``));``    ``}` `    ``// RUNNING LOOP FOR (k-1) TIMES``    ``for` `(``int` `i = ``1``; i < k; i++) {``      ``pair p = pq.peek();``      ``pq.remove();` `      ``// AFTER POPPING, WE'LL PUSH NEXT ELEMENT OF THE``      ``// ROW IN THE HEAP``      ``if` `(p.second + ``1` `< n)``        ``pq.add(``new` `pair(p.first, p.second + ``1``));``    ``}``    ``// ON THE k'th ITERATION, pq.top() will be our``    ``// answer.``    ``return` `mat[pq.peek().first][pq.peek().second];``  ``}` `  ``// driver program to test above function``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `mat[][] = {``      ``{ ``10``, ``20``, ``30``, ``40` `},``      ``{ ``15``, ``25``, ``35``, ``45` `},``      ``{ ``25``, ``29``, ``37``, ``48` `},``      ``{ ``32``, ``33``, ``39``, ``50` `},``    ``};``    ``System.out.println(``"7th smallest element is "``                       ``+ kthSmallest(mat, ``4``, ``7``));``  ``}``}` `// This code is contributed by Karandeep1234`

## Python3

 `# kth largest element in a 2d array sorted row-wise and``# column-wise` `import` `heapq` `def` `kthSmallest(mat, n, k):``    ``# Using lambda function``    ``# [=] in lambda function is for capturing variables which are out of scope i.e. mat[r]``    ``# Now, it'll compare elements of heap by elements at mat[first][second]``    ``# Capturing the value of mat by reference to prevent copying``    ``cmp` `=` `lambda` `a,b: mat[a[``0``]][a[``1``]] ``-` `mat[b[``0``]][b[``1``]]` `    ``# Declaring heap and pushing first element of each row in it``    ``heap ``=` `[(mat[i][``0``], i, ``0``) ``for` `i ``in` `range``(n)]``    ``heapq.heapify(heap)` `    ``# Running loop for k-1 times``    ``for` `i ``in` `range``(k``-``1``):``        ``val, row, col ``=` `heapq.heappop(heap)` `        ``# After popping, we'll push next element of the row in the heap``        ``if` `col < n``-``1``:``            ``heapq.heappush(heap, (mat[row][col``+``1``], row, col``+``1``))` `    ``# On the k'th iteration, heap[0] will be our answer``    ``return` `heap[``0``][``0``]` `# Driver program to test above function``mat ``=` `[``    ``[``10``, ``20``, ``30``, ``40``],``    ``[``15``, ``25``, ``35``, ``45``],``    ``[``25``, ``29``, ``37``, ``48``],``    ``[``32``, ``33``, ``39``, ``50``]``]` `print``(``"7th smallest element is"``, kthSmallest(mat, ``4``, ``7``))`

Output

`7th smallest element is 30`

Time Complexity: O(n log n)
Auxiliary Space: O(n)

### Using Binary Search over the Range:

This approach uses binary search to iterate over possible solutions. We know that

So we do a binary search on this range and in each  iteration determine the no of elements greater than or equal to our current middle element. The elements greater than or equal to current element can be found in O( n logn ) time using binary search.

## C++

 `#include ``using` `namespace` `std;` `// This returns count of elements in matrix less than of equal to num``int` `getElementsGreaterThanOrEqual(``int` `num, ``int` `n, ``int` `mat[4][4]) {``    ``int` `ans = 0;` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``// if num is less than the first element then no more element in matrix``        ``// further are less than or equal to num``        ``if` `(mat[i][0] > num) {``            ``return` `ans;``        ``}``        ``// if num is greater than last element, it is greater than all elements``        ``// in that row``        ``if` `(mat[i][n - 1] <= num) {``            ``ans += n;``            ``continue``;``        ``}``        ``// This contain the col index of last element in matrix less than of equal``        ``// to num``        ``int` `greaterThan = 0;``        ``for` `(``int` `jump = n / 2; jump >= 1; jump /= 2) {``            ``while` `(greaterThan + jump < n &&``                   ``mat[i][greaterThan + jump] <= num) {``                ``greaterThan += jump;``            ``}``        ``}` `        ``ans += greaterThan + 1;``    ``}``    ``return` `ans;``}` `// returns kth smallest index in the matrix``int` `kthSmallest(``int` `mat[4][4], ``int` `n, ``int` `k) {``    ``//  We know the answer lies between the first and the last element``    ``// So do a binary search on answer based on the number of elements``    ``// our current element is greater than the elements in the matrix``    ``int` `l = mat[0][0], r = mat[n - 1][n - 1];` `    ``while` `(l <= r) {``        ``int` `mid = l + (r - l) / 2;``        ``int` `greaterThanOrEqualMid = getElementsGreaterThanOrEqual(mid, n, mat);` `        ``if` `(greaterThanOrEqualMid >= k)``            ``r = mid - 1;``        ``else``            ``l = mid + 1;``    ``}``    ``return` `l;``}` `int` `main() {``    ``int` `n = 4;``    ``int` `mat[4][4] = {``        ``{10, 20, 30, 40},``        ``{15, 25, 35, 45},``        ``{25, 29, 37, 48},``        ``{32, 33, 39, 50},``    ``};``    ``cout << ``"7th smallest element is "` `<< kthSmallest(mat, 4, 7);``    ``return` `0;``}`

## Java

 `import` `java.io.*;` `class` `GFG {` `  ``// This returns count of elements in``  ``// matrix less than of equal to num``  ``static` `int` `getElementsGreaterThanOrEqual(``int` `num, ``int` `n, ``int` `mat[][])``  ``{``    ``int` `ans = ``0``;` `    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``      ` `      ``// if num is less than the first element``      ``// then no more element in matrix``      ``// further are less than or equal to num``      ``if` `(mat[i][``0``] > num) {``        ``return` `ans;``      ``}``      ` `      ``// if num is greater than last element,``      ``// it is greater than all elements``      ``// in that row``      ``if` `(mat[i][n - ``1``] <= num) {``        ``ans += n;``        ``continue``;``      ``}``      ` `      ``// This contain the col index of last element``      ``// in matrix less than of equal``      ``// to num``      ``int` `greaterThan = ``0``;``      ``for` `(``int` `jump = n / ``2``; jump >= ``1``; jump /= ``2``) {``        ``while` `(greaterThan + jump < n &&``               ``mat[i][greaterThan + jump] <= num) {``          ``greaterThan += jump;``        ``}``      ``}` `      ``ans += greaterThan + ``1``;``    ``}``    ``return` `ans;``  ``}` `  ``// returns kth smallest index in the matrix``  ``static` `int` `kthSmallest(``int` `mat[][], ``int` `n, ``int` `k)``  ``{``    ` `    ``// We know the answer lies between the first and the last element``    ``// So do a binary search on answer based on the number of elements``    ``// our current element is greater than the elements in the matrix``    ``int` `l = mat[``0``][``0``], r = mat[n - ``1``][n - ``1``];` `    ``while` `(l <= r) {``      ``int` `mid = l + (r - l) / ``2``;``      ``int` `greaterThanOrEqualMid = getElementsGreaterThanOrEqual(mid, n, mat);` `      ``if` `(greaterThanOrEqualMid >= k)``        ``r = mid - ``1``;``      ``else``        ``l = mid + ``1``;``    ``}``    ``return` `l;``  ``}` `  ``public` `static` `void` `main(String args[]) {``    ``int` `mat[][] = {``      ``{ ``10``, ``20``, ``30``, ``40` `},``      ``{ ``15``, ``25``, ``35``, ``45` `},``      ``{ ``25``, ``29``, ``37``, ``48` `},``      ``{ ``32``, ``33``, ``39``, ``50` `},``    ``};``    ``System.out.println(``"7th smallest element is "` `+ kthSmallest(mat, ``4``, ``7``));``  ``}` `}` `// This code is contributed by gfgking.`

## Python3

 `# This returns count of elements in matrix``# less than of equal to num``def` `getElementsGreaterThanOrEqual(num,n,mat):``    ``ans ``=` `0``    ``for` `i ``in` `range``(n):``      ` `        ``# if num is less than the first element``        ``# then no more element in matrix``        ``# further are less than or equal to num``        ``if` `(mat[i][``0``] > num):``            ``return` `ans``          ` `        ``# if num is greater than last element,``        ``# it is greater than all elements``        ``# in that row``        ``if` `(mat[i][n ``-` `1``] <``=` `num):``            ``ans ``+``=` `n``            ``continue``        ``# This contain the col index of last element``        ``# in matrix less than of equal``        ``# to num``        ``greaterThan ``=` `0``        ``jump ``=` `n ``/``/` `2``        ``while``(jump >``=` `1``):``                ``while` `(greaterThan ``+` `jump < n ``and` `mat[i][greaterThan ``+` `jump] <``=` `num):``                    ``greaterThan ``+``=` `jump``                ``jump ``/``/``=` `2` `        ``ans ``+``=` `greaterThan ``+` `1``    ``return` `ans` `# returns kth smallest index in the matrix``def` `kthSmallest(mat, n, k):` `    ``# We know the answer lies between``    ``# the first and the last element``    ``# So do a binary search on answer``    ``# based on the number of elements``    ``# our current element is greater than``    ``# the elements in the matrix``    ``l,r ``=` `mat[``0``][``0``],mat[n ``-` `1``][n ``-` `1``]` `    ``while` `(l <``=` `r):``        ``mid ``=` `l ``+` `(r ``-` `l) ``/``/` `2``        ``greaterThanOrEqualMid ``=` `getElementsGreaterThanOrEqual(mid, n, mat)` `        ``if` `(greaterThanOrEqualMid >``=` `k):``            ``r ``=` `mid ``-` `1``        ``else``:``            ``l ``=` `mid ``+` `1` `    ``return` `l` `# driver code``n ``=` `4``mat ``=` `[[``10``, ``20``, ``30``, ``40``],[``15``, ``25``, ``35``, ``45``],[``25``, ``29``, ``37``, ``48``],[``32``, ``33``, ``39``, ``50``]]``print``(f``"7th smallest element is {kthSmallest(mat, 4, 7)}"``)` `# This code is contributed by shinjanpatra`

## C#

 `using` `System;` `public` `class` `GFG``{` `  ``// This returns count of elements in``  ``// matrix less than of equal to num``  ``static` `int` `getElementsGreaterThanOrEqual(``int` `num, ``int` `n, ``int` `[,]mat)``  ``{``    ``int` `ans = 0;` `    ``for` `(``int` `i = 0; i < n; i++)``    ``{` `      ``// if num is less than the first element``      ``// then no more element in matrix``      ``// further are less than or equal to num``      ``if` `(mat[i,0] > num) {``        ``return` `ans;``      ``}` `      ``// if num is greater than last element,``      ``// it is greater than all elements``      ``// in that row``      ``if` `(mat[i,n - 1] <= num) {``        ``ans += n;``        ``continue``;``      ``}` `      ``// This contain the col index of last element``      ``// in matrix less than of equal``      ``// to num``      ``int` `greaterThan = 0;``      ``for` `(``int` `jump = n / 2; jump >= 1; jump /= 2) {``        ``while` `(greaterThan + jump < n &&``               ``mat[i,greaterThan + jump] <= num) {``          ``greaterThan += jump;``        ``}``      ``}` `      ``ans += greaterThan + 1;``    ``}``    ``return` `ans;``  ``}` `  ``// returns kth smallest index in the matrix``  ``static` `int` `kthSmallest(``int` `[,]mat, ``int` `n, ``int` `k)``  ``{` `    ``// We know the answer lies between the first and the last element``    ``// So do a binary search on answer based on the number of elements``    ``// our current element is greater than the elements in the matrix``    ``int` `l = mat[0,0], r = mat[n - 1,n - 1];` `    ``while` `(l <= r) {``      ``int` `mid = l + (r - l) / 2;``      ``int` `greaterThanOrEqualMid = getElementsGreaterThanOrEqual(mid, n, mat);` `      ``if` `(greaterThanOrEqualMid >= k)``        ``r = mid - 1;``      ``else``        ``l = mid + 1;``    ``}``    ``return` `l;``  ``}` `  ``public` `static` `void` `Main(String []args) {``    ``int` `[,]mat = {``      ``{ 10, 20, 30, 40 },``      ``{ 15, 25, 35, 45 },``      ``{ 25, 29, 37, 48 },``      ``{ 32, 33, 39, 50 },``    ``};``    ``Console.WriteLine(``"7th smallest element is "` `+ kthSmallest(mat, 4, 7));``  ``}` `}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`7th smallest element is 30`

Complexity Analysis

• Time Complexity : O( y * n*logn)
`Where y =  log( abs(Mat[0][0] - Mat[n-1][n-1]) )`
1. We call the getElementsGreaterThanOrEqual function  log ( abs(Mat[0][0] – Mat[n-1][n-1])  ) times
2. Time complexity of getElementsGreaterThanOrEqual is O(n logn) since there we do binary search n times.
• Auxiliary Space: O(1)

USING ARRAY:

We will make a new array and will copy all the contents of matrix in this array. After that we will sort that array and find kth smallest element. This will be so easier.

## C++

 `// C++ code to implement the approach``#include ``using` `namespace` `std;` `int` `kthSmallest(``int` `mat[4][4], ``int` `n, ``int` `k)``{` `  ``int` `a[n*n];``  ``int` `v = 0;` `  ``for``(``int` `i = 0; i < n; i++)``  ``{``    ``for``(``int` `j = 0; j < n; j++)``    ``{``      ``a[v] = mat[i][j];``      ``v++;``    ``}``  ``}` `  ``sort(a, a + (n*n));``  ``int` `result = a[k - 1];``  ``return` `result;``}` `// Driver code``int` `main()``{``  ``int` `mat[4][4] = { { 10, 20, 30, 40 },``                   ``{ 15, 25, 35, 45 },``                   ``{ 25, 29, 37, 48 },``                   ``{ 32, 33, 39, 50 } };``  ``int` `res = kthSmallest(mat, 4, 7);` `  ``cout <<  ``"7th smallest element is "` `<< res;``  ``return` `0;``}` `// This code is contributed by sanjoy_62.`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;``import` `java.util.*;` `class` `GFG {``    ``public` `static` `void` `main (String[] args) {``        ` `    ``int` `mat[][] = { { ``10``, ``20``, ``30``, ``40` `},``                    ``{ ``15``, ``25``, ``35``, ``45` `},``                    ``{ ``25``, ``29``, ``37``, ``48` `},``                    ``{ ``32``, ``33``, ``39``, ``50` `} };``      ``int` `res = kthSmallest(mat, ``4``, ``7``);``      ` `    ``System.out.print(``"7th smallest element is "``+ res);``    ``}``  ` `   ``static` `int` `kthSmallest(``int``[][]mat,``int` `n,``int` `k)``    ``{``         ` `       ``int``[] a=``new` `int``[n*n];``       ``int` `v=``0``;``       ` `       ``for``(``int` `i=``0``;i

## Python3

 `# Python program to implement above approach``def` `kthSmallest(mat, n, k):``        ` `    ``a ``=` `[``0` `for` `i ``in` `range``(n``*``n)]``    ``v``=``0``        ` `    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(n):``            ``a[v] ``=` `mat[i][j]``            ``v ``+``=` `1``            ` `    ``a.sort()``    ``result ``=` `a[k ``-` `1``]``    ``return` `result` `# driver program``        ` `mat ``=` `[ [ ``10``, ``20``, ``30``, ``40` `],``            ``[ ``15``, ``25``, ``35``, ``45` `],``            ``[ ``25``, ``29``, ``37``, ``48` `],``            ``[ ``32``, ``33``, ``39``, ``50` `] ]``res ``=` `kthSmallest(mat, ``4``, ``7``)``    ` `print``(``"7th smallest element is "``+` `str``(res))` `# This code is contributed by shinjanpatra`

## C#

 `/*package whatever //do not write package name here */``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG {``  ``public` `static` `void` `Main(String[] args) {` `    ``int` `[,]mat = { { 10, 20, 30, 40 },``                  ``{ 15, 25, 35, 45 },``                  ``{ 25, 29, 37, 48 },``                  ``{ 32, 33, 39, 50 } };``    ``int` `res = kthSmallest(mat, 4, 7);` `    ``Console.Write(``"7th smallest element is "``+ res);``  ``}` `  ``static` `int` `kthSmallest(``int``[,]mat, ``int` `n, ``int` `k)``  ``{` `    ``int``[] a = ``new` `int``[n*n];``    ``int` `v = 0;` `    ``for``(``int` `i = 0; i < n; i++)``    ``{``      ``for``(``int` `j = 0; j < n; j++)``      ``{``        ``a[v] = mat[i, j];``        ``v++;``      ``}``    ``}` `    ``Array.Sort(a);``    ``int` `result = a[k - 1];``    ``return` `result;``  ``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`7th smallest element is 30`

Time Complexity: O(n2
Auxiliary Space: O(n2)

Using Priority queue approach

## C++14

 `#include ``using` `namespace` `std;``int` `kthSmallest(vector>& matrix, ``int` `k) {``  ``//n = size of matrix``  ``int` `i,j,n=matrix.size();``  ` `  ``//using built-in priority queue which acts as max Heap i.e. largest element will be on top``  ``//Kth smallest element can also be seen as largest element in a priority queue of size k``  ``//By this logic we pop elements from priority queue when its size becomes greater than k``  ``//thus top of priority queue is kth smallest element in matrix``  ` `  ``priority_queue<``int``> maxH;``  ``if``(k==1)``    ``return` `matrix[0][0];``  ` `  ``for``(i=0;ik)``        ``maxH.pop();``    ``}``  ``}``  ` `  ``return` `maxH.top();``}``int` `main() {` `    ``vector> matrix = {{1,5,9},{10,11,13},{12,13,15}};``      ``int` `k = 8;``    ``cout << ``"8th smallest element is "` `<< kthSmallest(matrix,k);``    ``return` `0;``}`

## Java

 `import` `java.util.*;``import` `java.io.*;` `public` `class` `Main {``  ``public` `static` `int` `kthSmallest(``int``[][] matrix, ``int` `k)``  ``{``    ` `    ``// n = size of matrix``    ``int` `i, j, n = matrix.length;` `    ``// using built-in priority queue which acts as max``    ``// Heap i.e. largest element will be on top``    ``// Kth smallest element can also be seen as largest``    ``// element in a priority queue of size k By this``    ``// logic we pop elements from priority queue when``    ``// its size becomes greater than k thus top of``    ``// priority queue is kth smallest element in matrix` `    ``PriorityQueue maxH = ``new` `PriorityQueue<>(``      ``Collections.reverseOrder());``    ``if` `(k == ``1``)``      ``return` `matrix[``0``][``0``];` `    ``for` `(i = ``0``; i < n; i++) {``      ``for` `(j = ``0``; j < n; j++) {``        ``maxH.add(matrix[i][j]);``        ``if` `(maxH.size() > k)``          ``maxH.poll();``      ``}``    ``}` `    ``return` `maxH.peek();``  ``}``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int``[][] matrix = { { ``1``, ``5``, ``9` `},``                      ``{ ``10``, ``11``, ``13` `},``                      ``{ ``12``, ``13``, ``15` `} };``    ``int` `k = ``8``;``    ``System.out.print(``"8th smallest element is "``                     ``+ kthSmallest(matrix, k));``  ``}``}` `// This code is contributed by tapeshdua420.`

## Python3

 `import` `heapq`  `def` `kthSmallest(matrix, k):``    ``# n = size of matrix``    ``n ``=` `len``(matrix)` `    ``# using built-in priority queue which acts as max Heap i.e. largest element will be on top``    ``# Kth smallest element can also be seen as largest element in a priority queue of size k``    ``# By this logic we pop elements from priority queue when its size becomes greater than k``    ``# thus top of priority queue is kth smallest element in matrix` `    ``maxH ``=` `[]``    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(n):``            ``heapq.heappush(maxH, ``-``matrix[i][j])``            ``if` `len``(maxH) > k:``                ``heapq.heappop(maxH)``    ``return` `-``maxH[``0``]`  `matrix ``=` `[[``1``, ``5``, ``9``], [``10``, ``11``, ``13``], [``12``, ``13``, ``15``]]``k ``=` `8``print``(``"8th smallest element is"``, kthSmallest(matrix, k))` `# This code is contributed by Tapesh (tapeshdua420)`

## C#

 `using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG {``  ``public` `static` `int` `kthSmallest(``int``[,] matrix, ``int` `k)``  ``{` `    ``// n = size of matrix``    ``int` `i, j, n = matrix.GetLength(0);` `    ``// using built-in priority queue which acts as max``    ``// Heap i.e. largest element will be on top``    ``// Kth smallest element can also be seen as largest``    ``// element in a priority queue of size k By this``    ``// logic we pop elements from priority queue when``    ``// its size becomes greater than k thus top of``    ``// priority queue is kth smallest element in matrix` `    ``List<``int``> maxH = ``new` `List<``int``>();``    ``if` `(k == 1)``      ``return` `matrix[0,0];` `    ``for` `(i = 0; i < n; i++) {``      ``for` `(j = 0; j < n; j++) {``        ``maxH.Add(matrix[i,j]);``        ``if` `(maxH.Count > k){``          ``maxH.Sort((a, b) => b.CompareTo(a));``          ``maxH.RemoveAt(0);``        ``}``      ``}``    ``}``    ``maxH.Sort((a, b) => b.CompareTo(a));``    ``return` `maxH[0];``  ``}``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``int``[,] matrix = { { 1, 5, 9 },``                     ``{ 10, 11, 13 },``                     ``{ 12, 13, 15 } };``    ``int` `k = 8;``    ``Console.Write(``"8th smallest element is "``                  ``+ kthSmallest(matrix, k));``  ``}``}` `// This code is contributed by shikhasingrajput`

## Javascript

 ``

Output

`8th smallest element is 13`

Time Complexity: O(log(k)*n2)
Auxiliary Space: O(n)