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

• Difficulty Level : Hard
• Last Updated : 29 Aug, 2021

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: Please solve it on “PRACTICE” first, before moving on to the solution.

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 <bits/stdc++.h>
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<heap_size && harr[l].val < harr[i].val && harr[r].val < harr[i].val){
HeapNode 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=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[][]
int kthSmallest(int mat[4][4], int n, int k)
{
// k must be greater than 0 and smaller than n*n
if (k < 0 && k >= 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
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
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<heap_size && harr[l].val < harr[i].val && harr[r].val < harr[i].val){
HeapNode 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=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 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<heap_size and harr[l].val < harr[i].val and harr[r].val < harr[i].val):
temp= 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 and harr[l].val < harr[i].val):
temp= 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[][]
def kthSmallest(mat, n, k):

# k must be greater than 0 and smaller than n*n
if k < 0 or k > 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
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

```<script>
// Javascript program for kth largest element in a 2d
// array sorted row-wise and column-wise

// A structure to store entry of heap.
// The entry contains value from 2D array,
// row and column numbers of the value
class HeapNode
{
constructor(val,r,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[]
function minHeapify(harr,i,heap_size)
{
let l = 2 * i + 1;
let r = 2 * i + 2;
let min = i;

if(l < heap_size&& r<heap_size && harr[l].val < harr[i].val && harr[r].val < harr[i].val){
let 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){
let 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[][]
function kthSmallest(mat,n,k)
{
// k must be greater than 0 and
// smaller than n*n
if (k < 0 && k >= n * n)
return Number.MAX_VALUE;

// Create a min heap of elements
// from first row of 2D array
let harr = new Array(n);

for(let i = 0; i < n; i++)
{
harr[i] = new HeapNode(mat[0][i], 0, i);
}

let hr = new HeapNode(0, 0, 0);

for(let 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
let nextVal = hr.r < n - 1 ?
mat[hr.r + 1][hr.c] :
Number.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
let mat=[[ 10, 20, 30, 40 ],
[ 15, 25, 35, 45 ],
[ 25, 29, 37, 48 ],
[ 32, 33, 39, 50 ]];
let res = kthSmallest(mat, 4, 7);
document.write("7th smallest element is "+ res);

// This code is contributed by avanitrachhadiya2155
</script>
```
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.
• Space Complexity: 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<bits/stdc++.h>
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<pair<int,int>,vector<pair<int,int>>,decltype(cmp)> pq(cmp);
for(int i=0; i<n; i++){
pq.push({i,0});
}

//RUNNING LOOP FOR (k-1) TIMES
for(int i=1; i<k; i++){
auto p = pq.top();
pq.pop();

//AFTER POPPING, WE'LL PUSH NEXT ELEMENT OF THE ROW IN THE HEAP
if(p.second+1 < n) pq.push({p.first,p.second + 1});
}
// ON THE k'th ITERATION, pq.top() will be our answer.
return mat[pq.top().first][pq.top().second];
}

// 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;
}
```
Output
`7th smallest element is 30`

### 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 <bits/stdc++.h>
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;
}

// reuturs 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;
}
```

## Javascript

```<script>

// This returns count of elements in matrix
// less than of equal to num
function getElementsGreaterThanOrEqual(num,n,mat)
{
let ans = 0

for (let 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
let greaterThan = 0;
for (let jump = n / 2; jump >= 1; jump /= 2) {
while (greaterThan + jump < n &&
mat[i][greaterThan + jump] <= num) {
greaterThan += jump;
}
}

ans += greaterThan + 1;
}
return ans;
}

// reuturs kth smallest index in the matrix
function 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
let l = mat[0][0], r = mat[n - 1][n - 1];

while (l <= r) {
let mid = l + parseInt((r - l) / 2, 10);
let greaterThanOrEqualMid =
getElementsGreaterThanOrEqual(mid, n, mat);

if (greaterThanOrEqualMid >= k)
r = mid - 1;
else
l = mid + 1;
}
return l;
}

let n = 4;
let mat = [
[10, 20, 30, 40],
[15, 25, 35, 45],
[25, 29, 37, 48],
[32, 33, 39, 50],
];
document.write("7th smallest element is " +
kthSmallest(mat, 4, 7));

</script>```

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.
• Space Complexity: 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.

## 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<n;i++){
for(int j=0;j<n;j++){
a[v]=mat[i][j];
v++;
}
}

Arrays.sort(a);
int result=a[k-1];
return result;
}
}
```
Output
`7th smallest element is 30`

My Personal Notes arrow_drop_up