Given two sorted arrays a[] of size m and b[] of size n, find the k-th smallest element in the combined sorted sequence of all elements from both arrays.
Assume 1-based indexing for k, and that 1 ≤ k ≤ m + n.
Examples:
Input: a[] = [2, 3, 6, 7, 9], b[] = [1, 4, 8, 10], k = 5
Output: 6
Explanation: The final sorted array is [1, 2, 3, 4, 6, 7, 8, 9, 10]. The 5th element is 6.Input: a[] = [1, 2, 2], b[] = [2, 3, 4], k = 4
Output: 2
Explanation: Merged array = [1, 2, 2, 2, 3, 4], 4th element = 2.
Try it on GfG Practice
Table of Content
- [Naive Approach 1] Using Sorting - O((m + n) × log(m + n)) Time and O(m + n) Space
- [Naive Approach 2] Using Priority Queue - O((m + n + k) × log(m + n)) Time and O(m + n) Space
- [Better Approach 1] Using Merge Step of Merge Sort - O(m + n) Time and O(m + n) Space
- [Better Approach 2] Using Optimized Merge of Merge Sort - O(k) Time and O(1) Space
- [Expected Approach] Using Binary Search - O(log min(n, m)) Time and O(1) Space
[Naive Approach 1] Using Sorting - O((m + n) × log(m + n)) Time and O(m + n) Space
The idea is to combine both arrays into a single array, then sort the combined array to get all elements in order. The kth smallest element is returned directly using its index after sorting.
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int kthElement(vector<int> &a, vector<int> &b, int k) {
// to merge both the arrays
vector<int> arr;
// add the elements of array a
for(auto i: a)
arr.push_back(i);
// add the elements of array a
for(auto i: b)
arr.push_back(i);
// sort the merged array
sort(arr.begin(), arr.end());
// return the kth element
return arr[k-1];
}
int main() {
vector<int> a = {2, 3, 6, 7, 9};
vector<int> b = {1, 4, 8, 10};
int k = 5;
cout << kthElement(a, b, k);
return 0;
}
import java.util.Collections;
import java.util.ArrayList;
class GfG {
static int kthElement(int[] a, int[] b, int k) {
// to merge both the arrays
ArrayList<Integer> arr = new ArrayList<>();
// add the elements of array a
for (int i : a)
arr.add(i);
// add the elements of array b
for (int i : b)
arr.add(i);
// sort the merged array
Collections.sort(arr);
// return the kth element
return arr.get(k - 1);
}
public static void main(String[] args) {
int[] a = {2, 3, 6, 7, 9};
int[] b = {1, 4, 8, 10};
int k = 5;
System.out.println(kthElement(a, b, k));
}
}
def kthElement(a, b, k):
# to merge both the arrays
arr = []
# add the elements of array a
for i in a:
arr.append(i)
# add the elements of array b
for i in b:
arr.append(i)
# sort the merged array
arr.sort()
# return the kth element
return arr[k - 1]
if __name__ == "__main__":
a = [2, 3, 6, 7, 9]
b = [1, 4, 8, 10]
k = 5
print(kthElement(a, b, k))
using System;
using System.Collections.Generic;
class GfG {
static int kthElement(int[] a, int[] b, int k) {
// to merge both the arrays
List<int> arr = new List<int>();
// add the elements of array a
foreach (int i in a)
arr.Add(i);
// add the elements of array b
foreach (int i in b)
arr.Add(i);
// sort the merged array
arr.Sort();
// return the kth element
return arr[k - 1];
}
static void Main() {
int[] a = {2, 3, 6, 7, 9};
int[] b = {1, 4, 8, 10};
int k = 5;
Console.WriteLine(kthElement(a, b, k));
}
}
function kthElement(a, b, k) {
// to merge both the arrays
let arr = [];
// add the elements of array a
for (let i of a)
arr.push(i);
// add the elements of array b
for (let i of b)
arr.push(i);
// sort the merged array
arr.sort((x, y) => x - y);
// return the kth element
return arr[k - 1];
}
// Driver Code
let a = [2, 3, 6, 7, 9];
let b = [1, 4, 8, 10];
let k = 5;
console.log(kthElement(a, b, k));
Output
6
[Naive Approach 2] Using Priority Queue - O((m + n + k) × log(m + n)) Time and O(m + n) Space
The idea is to insert all elements from both sorted arrays into a min-heap, which automatically keeps the smallest elements at the top. Then, by removing the smallest element k - 1 times, the kth smallest element will be at the top of the heap. This approach ensures the elements are processed in sorted order without full array sorting.
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
int kthElement(vector<int> &a, vector<int> &b, int k){
// to store the elements of both
// the arrays in sorted order
priority_queue<int, vector<int>, greater<int>> pq;
// add the elements of array a
for(auto i: a)
pq.push(i);
// add the elements of array a
for(auto i: b)
pq.push(i);
// pop the elements from the heap
// till k-1 elements are popped
while(k-- > 1)
pq.pop();
// return the kth element
return pq.top();
}
int main() {
vector<int> a = {2, 3, 6, 7, 9};
vector<int> b = {1, 4, 8, 10};
int k = 5;
cout << kthElement(a, b, k);
return 0;
}
import java.util.PriorityQueue;
class GfG {
static int kthElement(int[] a, int[] b, int k){
// to store the elements of both
// the arrays in sorted order
PriorityQueue<Integer> pq =
new PriorityQueue<>();
// add the elements of array a
for (int i : a)
pq.add(i);
// add the elements of array a
for (int i : b)
pq.add(i);
// pop the elements from the heap
// till k-1 elements are popped
while (k-- > 1)
pq.poll();
// return the kth element
return pq.peek();
}
public static void main(String[] args) {
int[] a = {2, 3, 6, 7, 9};
int[] b = {1, 4, 8, 10};
int k = 5;
System.out.println(kthElement(a, b, k));
}
}
import heapq
def kthElement(a, b, k):
# to store the elements of both
# the arrays in sorted order
pq = []
# add the elements of array a
for i in a:
heapq.heappush(pq, i)
# add the elements of array a
for i in b:
heapq.heappush(pq, i)
# pop the elements from the heap
# till k-1 elements are popped
while k > 1:
heapq.heappop(pq)
k -= 1
# return the kth element
return pq[0]
if __name__ == "__main__":
a = [2, 3, 6, 7, 9]
b = [1, 4, 8, 10]
k = 5
print(kthElement(a, b, k))
using System;
using System.Collections.Generic;
class GfG {
public static int kthElement(List<int> a, List<int> b, int k) {
// to store the elements of both
// the arrays in sorted order
SortedDictionary<int, Queue<int>> map =
new SortedDictionary<int, Queue<int>>();
// add the elements of array a
foreach (int i in a) {
if (!map.ContainsKey(i))
map[i] = new Queue<int>();
map[i].Enqueue(i);
}
// add the elements of array b
foreach (int i in b) {
if (!map.ContainsKey(i))
map[i] = new Queue<int>();
map[i].Enqueue(i);
}
// pop the elements from the map
// till k-1 elements are popped
while (k-- > 1) {
int minKey = firstKey(map);
map[minKey].Dequeue();
if (map[minKey].Count == 0)
map.Remove(minKey);
}
// return the kth element
return firstKey(map);
}
// helper to get first (smallest) key
public static int firstKey(SortedDictionary<int, Queue<int>> map){
foreach (var kvp in map)
return kvp.Key;
return -1;
}
public static void Main(string[] args) {
List<int> a = new List<int> { 2, 3, 6, 7, 9 };
List<int> b = new List<int> { 1, 4, 8, 10 };
int k = 5;
Console.WriteLine(kthElement(a, b, k));
}
}
function kthElement(a, b, k) {
// to store the elements of both
// the arrays in sorted order
let pq = [];
// add the elements of array a
for (let i of a)
pq.push(i);
// add the elements of array a
for (let i of b)
pq.push(i);
// sort the merged array in ascending order
pq.sort((x, y) => x - y);
// pop the elements from the heap
// till k-1 elements are popped
while (k-- > 1)
pq.shift();
// return the kth element
return pq[0];
}
// Driver Code
let a = [2, 3, 6, 7, 9];
let b = [1, 4, 8, 10];
let k = 5;
console.log(kthElement(a, b, k));
Output
6
[Better Approach 1] Using Merge Step of Merge Sort - O(m + n) Time and O(m + n) Space
The basic idea here is to merge the given two arrays into a single sorted array and then simply return the element at the kth position. This approach is straightforward because it directly uses the merging process of two sorted arrays, similar to the merge step in the merge sort algorithm.
Step-by-step approach:
- We initialize three pointers: two pointers to traverse each array and one to keep track of the position in the merged array.
- By comparing the elements pointed to by the two array pointers, we place the smaller element into the merged array and move the respective pointer forward.
- This continues until one of the arrays is fully traversed.
- If any elements remain in either array, they are directly appended to the merged array.
- Finally, the k-th element of this merged array is returned.
#include <iostream>
#include <vector>
using namespace std;
int kthElement(vector<int> &a, vector<int> &b, int k){
int n = a.size(), m = b.size();
// array to store the merged sorted array
vector<int> arr(n + m);
int i = 0, j = 0, d = 0;
while (i < n && j < m) {
// if the element of a[] is smaller, insert
// the element to the sorted array
if (a[i] < b[j])
arr[d++] = a[i++];
// if the element of b[] is smaller, insert
// the element to the sorted array
else
arr[d++] = b[j++];
}
// push the remaining elements of a[]
while (i < n)
arr[d++] = a[i++];
// push the remaining elements of b[]
while (j < m)
arr[d++] = b[j++];
return arr[k - 1];
}
int main() {
vector<int> a = {2, 3, 6, 7, 9};
vector<int> b = {1, 4, 8, 10};
int k = 5;
cout << kthElement(a, b, k);
return 0;
}
class GfG {
static int kthElement(int[] a, int[] b, int k) {
int n = a.length, m = b.length;
// array to store the merged sorted array
int[] arr = new int[n + m];
int i = 0, j = 0, d = 0;
while (i < n && j < m) {
// if the element of a[] is smaller, insert
// the element to the sorted array
if (a[i] < b[j]) {
arr[d++] = a[i++];
}
// if the element of b[] is smaller, insert
// the element to the sorted array
else {
arr[d++] = b[j++];
}
}
// push the remaining elements of a[]
while (i < n) {
arr[d++] = a[i++];
}
// push the remaining elements of b[]
while (j < m) {
arr[d++] = b[j++];
}
return arr[k - 1];
}
public static void main(String[] args) {
int[] a = {2, 3, 6, 7, 9};
int[] b = {1, 4, 8, 10};
int k = 5;
System.out.println(kthElement(a, b, k));
}
}
def kthElement(a, b, k):
n = len(a)
m = len(b)
# array to store the merged sorted array
arr = [0] * (n + m)
i = 0
j = 0
d = 0
while i < n and j < m:
# if the element of a[] is smaller, insert
# the element to the sorted array
if a[i] < b[j]:
arr[d] = a[i]
i += 1
# if the element of b[] is smaller, insert
# the element to the sorted array
else:
arr[d] = b[j]
j += 1
d += 1
# push the remaining elements of a[]
while i < n:
arr[d] = a[i]
i += 1
d += 1
# push the remaining elements of b[]
while j < m:
arr[d] = b[j]
j += 1
d += 1
return arr[k - 1]
if __name__ == "__main__":
arr1 = [2, 3, 6, 7, 9]
arr2 = [1, 4, 8, 10]
k = 5
print(kthElement(arr1, arr2, k))
using System;
class GfG {
static int kthElement(int[] a, int[] b, int k) {
int n = a.Length, m = b.Length;
// array to store the merged sorted array
int[] arr = new int[n + m];
int i = 0, j = 0, d = 0;
while (i < n && j < m) {
// if the element of a[] is smaller, insert
// the element to the sorted array
if (a[i] < b[j])
arr[d++] = a[i++];
// if the element of b[] is smaller, insert
// the element to the sorted array
else
arr[d++] = b[j++];
}
// push the remaining elements of a[]
while (i < n)
arr[d++] = a[i++];
// push the remaining elements of b[]
while (j < m)
arr[d++] = b[j++];
return arr[k - 1];
}
static void Main() {
int[] a = { 2, 3, 6, 7, 9 };
int[] b = { 1, 4, 8, 10 };
int k = 5;
Console.WriteLine(kthElement(a, b, k));
}
}
function kthElement(a, b, k) {
const n = a.length, m = b.length;
// array to store the merged sorted array
let arr = new Array(n + m);
let i = 0, j = 0, d = 0;
while (i < n && j < m) {
// if the element of a[] is smaller, insert
// the element to the sorted array
if (a[i] < b[j])
arr[d++] = a[i++];
// if the element of b[] is smaller, insert
// the element to the sorted array
else
arr[d++] = b[j++];
}
// push the remaining elements of a[]
while (i < n)
arr[d++] = a[i++];
// push the remaining elements of b[]
while (j < m)
arr[d++] = b[j++];
return arr[k - 1];
}
// Driver code
let a = [2, 3, 6, 7, 9];
let b = [1, 4, 8, 10];
let k = 5;
console.log(kthElement(a, b, k));
Output
6
[Better Approach 2] Using Optimized Merge of Merge Sort - O(k) Time and O(1) Space
The idea is to simulate the process of merging two sorted arrays, similar to the merge step in merge sort, but only until the k-th element is reached. We use two pointers, one for each array, and at each step, we choose the smaller of the two current elements to move forward. This way, we don't need to fully merge both arrays. We only track the last selected element, which will be the k-th smallest.
#include <iostream>
#include <vector>
using namespace std;
int kthElement(vector<int> &a, vector<int> &b, int k){
int n = a.size(), m = b.size();
// last element added to the merged
// sorted array
int last = 0;
int i = 0, j = 0;
for (int d = 0; d < k; ++d) {
if (i < n) {
// if a[i] > b[j] then increment j
if (j < m && a[i] > b[j]) {
last = b[j];
j++;
}
// otherwise increment i
else {
last = a[i];
i++;
}
}
// if reached end of first array then
// increment j
else if (j < m) {
last = b[j];
j++;
}
}
// return the last (kth) element
return last;
}
int main() {
vector<int> a = {2, 3, 6, 7, 9};
vector<int> b = {1, 4, 8, 10};
int k = 5;
cout << kthElement(a, b, k) << endl;
return 0;
}
class GfG {
static int kthElement(int[] a, int[] b, int k){
int n = a.length, m = b.length;
// last element added to the merged
// sorted array
int last = 0;
int i = 0, j = 0;
for (int d = 0; d < k; ++d) {
if (i < n) {
// if a[i] > b[j] then increment j
if (j < m && a[i] > b[j]) {
last = b[j];
j++;
}
// otherwise increment i
else {
last = a[i];
i++;
}
}
// if reached end of first array then
// increment j
else if (j < m) {
last = b[j];
j++;
}
}
// return the last (kth) element
return last;
}
public static void main(String[] args) {
int[] a = {2, 3, 6, 7, 9};
int[] b = {1, 4, 8, 10};
int k = 5;
System.out.println(kthElement(a, b, k));
}
}
def kthElement(a, b, k):
n, m = len(a), len(b)
# last element added to the merged
# sorted array
last = 0
i, j = 0, 0
for _ in range(k):
if i < n:
# If a[i] > b[j] then increment j
if j < m and a[i] > b[j]:
last = b[j]
j += 1
# Otherwise increment i
else:
last = a[i]
i += 1
# if reached end of first array then
# increment j
elif j < m:
last = b[j]
j += 1
# Return the last (kth) element
return last
if __name__ == "__main__":
a = [2, 3, 6, 7, 9]
b = [1, 4, 8, 10]
k = 5
print(kthElement(a, b, k))
using System;
class GfG {
static int KthElement(int[] a, int[] b, int k){
int n = a.Length, m = b.Length;
// last element added to the merged
// sorted array
int last = 0;
int i = 0, j = 0;
for (int d = 0; d < k; ++d) {
if (i < n) {
// if a[i] > b[j] then increment j
if (j < m && a[i] > b[j]) {
last = b[j];
j++;
}
// otherwise increment i
else {
last = a[i];
i++;
}
}
// if reached end of first array then
// increment j
else if (j < m) {
last = b[j];
j++;
}
}
// return the last (kth) element
return last;
}
public static void Main(string[] args) {
int[] a = { 2, 3, 6, 7, 9 };
int[] b = { 1, 4, 8, 10 };
int k = 5;
Console.WriteLine(KthElement(a, b, k));
}
}
function kthElement(a, b, k) {
const n = a.length, m = b.length;
// last element added to the merged
// sorted array
let last = 0;
let i = 0, j = 0;
for (let d = 0; d < k; ++d) {
if (i < n) {
// if a[i] > b[j] then increment j
if (j < m && a[i] > b[j]) {
last = b[j];
j++;
}
// otherwise increment i
else {
last = a[i];
i++;
}
}
// if reached end of first array then
// increment j
else if (j < m) {
last = b[j];
j++;
}
}
// return the last (kth) element
return last;
}
// Driver code
const a = [2, 3, 6, 7, 9];
const b = [1, 4, 8, 10];
const k = 5;
console.log(kthElement(a, b, k));
Output
6
[Expected Approach] Using Binary Search - O(log min(n, m)) Time and O(1) Space
The approach is similar to the Binary Search approach of Median of two sorted arrays of different sizes.
Consider the first array is smaller. If first array is greater, then swap the arrays to make sure that the first array is smaller.
- We mainly maintain two sets in this algorithm by doing binary search in the smaller array. Let mid1 be the partition of the smaller array. The first set contains elements from 0 to (mid1 – 1) from smaller array and mid2 = (k – mid1) elements from the greater array to make sure that the first set has exactly k elements. The second set contains remaining elements.
- Our target is to find a point in both arrays such that all elements in the first set are smaller than all elements in the other set (set that contains elements from right side). For this we validate the partitions using the same way as we did in Median of two sorted arrays of different sizes.
#include <iostream>
#include <vector>
#include <climits>
using namespace std;
int kthElement(vector<int> &a, vector<int> &b, int k) {
int n = a.size(), m = b.size();
// if a[] has more elements, then call
// kthElement with reversed parameters
if (n > m)
return kthElement(b, a, k);
// binary Search on the number of elements we can
// include in the first set from a[]
int lo = max(0, k - m), hi = min(k, n);
while (lo <= hi) {
int mid1 = (lo + hi) / 2;
int mid2 = k - mid1;
// find elements to the left and right of
// partition in a[]
int l1 = (mid1 == 0 ? INT_MIN : a[mid1 - 1]);
int r1 = (mid1 == n ? INT_MAX : a[mid1]);
// find elements to the left and right of
// partition in b[]
int l2 = (mid2 == 0 ? INT_MIN : b[mid2 - 1]);
int r2 = (mid2 == m ? INT_MAX : b[mid2]);
// if it is a valid partition
if (l1 <= r2 && l2 <= r1) {
// find and return the maximum of l1 and l2
return max(l1, l2);
}
// check if we need to take lesser elements from a[]
if (l1 > r2)
hi = mid1 - 1;
// check if we need to take more elements from a[]
else
lo = mid1 + 1;
}
return 0;
}
int main() {
vector<int> a = {2, 3, 6, 7, 9};
vector<int> b = {1, 4, 8, 10};
int k = 5;
cout << kthElement(a, b, k);
return 0;
}
class GfG {
static int kthElement(int[] a, int[] b, int k) {
int n = a.length, m = b.length;
// if a[] has more elements, then call
// kthElement with reversed parameters
if (n > m)
return kthElement(b, a, k);
// binary Search on the number of elements we
// can include in the first set from a[]
int lo = Math.max(0, k - m), hi = Math.min(k, n);
while (lo <= hi) {
int mid1 = (lo + hi) / 2;
int mid2 = k - mid1;
// find elements to the left and right of
// partition in a[]
int l1 = (mid1 == 0 ? Integer.MIN_VALUE :
a[mid1 - 1]);
int r1 = (mid1 == n ? Integer.MAX_VALUE :
a[mid1]);
// find elements to the left and right of
// partition in a[]
int l2 = (mid2 == 0 ? Integer.MIN_VALUE :
b[mid2 - 1]);
int r2 = (mid2 == m ? Integer.MAX_VALUE :
b[mid2]);
// if it is a valid partition
if (l1 <= r2 && l2 <= r1) {
// find and return the maximum of l1 and l2
return Math.max(l1, l2);
}
// check if we need to take lesser elements
// from a[]
if (l1 > r2)
hi = mid1 - 1;
// check if we need to take more elements
// from a[]
else
lo = mid1 + 1;
}
return 0;
}
public static void main(String[] args) {
int[] a = {2, 3, 6, 7, 9};
int[] b = {1, 4, 8, 10};
int k = 5;
System.out.println(kthElement(a, b, k));
}
}
def kthElement(a, b, k):
n = len(a)
m = len(b)
# if a[] has more elements, then call kthElement
# with reversed parameters
if n > m:
return kthElement(b, a, k)
# binary Search on the number of elements we can
# include in the first set from a[]
lo = max(0, k - m)
hi = min(k, n)
while lo <= hi:
mid1 = (lo + hi) // 2
mid2 = k - mid1
# find elements to the left and right of
# partition in a[]
l1 = (mid1 == 0 and float('-inf') or a[mid1 - 1])
r1 = (mid1 == n and float('inf') or a[mid1])
# find elements to the left and right of
# partition in b[]
l2 = (mid2 == 0 and float('-inf') or b[mid2 - 1])
r2 = (mid2 == m and float('inf') or b[mid2])
# if it is a valid partition
if l1 <= r2 and l2 <= r1:
# find and return the maximum of l1 and l2
return max(l1, l2)
# check if we need to take lesser elements
# from a[]
if l1 > r2:
hi = mid1 - 1
# check if we need to take more elements
# from a[]
else:
lo = mid1 + 1
return 0
if __name__ == "__main__":
a = [2, 3, 6, 7, 9]
b = [1, 4, 8, 10]
k = 5
print(kthElement(a, b, k))
using System;
class GfG {
static int kthElement(int[] a, int[] b, int k) {
int n = a.Length, m = b.Length;
// if a[] has more elements, then call kthElement
// with reversed parameters
if (n > m)
return kthElement(b, a, k);
// binary Search on the number of elements we can
// include in the first set from a[]
int lo = Math.Max(0, k - m), hi = Math.Min(k, n);
while (lo <= hi) {
int mid1 = (lo + hi) / 2;
int mid2 = k - mid1;
// find elements to the left and right of
// partition in a[]
int l1 = (mid1 == 0 ? Int32.MinValue : a[mid1 - 1]);
int r1 = (mid1 == n ? Int32.MaxValue : a[mid1]);
// find elements to the left and right of
// partition in b[]
int l2 = (mid2 == 0 ? Int32.MinValue : b[mid2 - 1]);
int r2 = (mid2 == m ? Int32.MaxValue : b[mid2]);
// if it is a valid partition
if (l1 <= r2 && l2 <= r1) {
// find and return the maximum of l1 and l2
return Math.Max(l1, l2);
}
// check if we need to take lesser
// elements from a[]
if (l1 > r2)
hi = mid1 - 1;
// check if we need to take more
// elements from a[]
else
lo = mid1 + 1;
}
return 0;
}
static void Main() {
int[] a = { 2, 3, 6, 7, 9 };
int[] b = { 1, 4, 8, 10 };
int k = 5;
Console.WriteLine(kthElement(a, b, k));
}
}
function kthElement(a, b, k) {
let n = a.length, m = b.length;
// if a[] has more elements, then call kthElement
// with reversed parameters
if (n > m) {
return kthElement(b, a, k);
}
// binary Search on the number of elements we can
// include in the first set from a[]
let lo = Math.max(0, k - m), hi = Math.min(k, n);
while (lo <= hi) {
let mid1 = Math.floor((lo + hi) / 2);
let mid2 = k - mid1;
// find elements to the left and right of partition in a[]
let l1 = (mid1 === 0 ? -Infinity : a[mid1 - 1]);
let r1 = (mid1 === n ? Infinity : a[mid1]);
// find elements to the left and right of partition in b[]
let l2 = (mid2 === 0 ? -Infinity : b[mid2 - 1]);
let r2 = (mid2 === m ? Infinity : b[mid2]);
// if it is a valid partition
if (l1 <= r2 && l2 <= r1) {
// find and return the maximum of l1 and l2
return Math.max(l1, l2);
}
// check if we need to take lesser
// elements from a[]
if (l1 > r2) {
hi = mid1 - 1;
}
// check if we need to take more
// elements from a[]
else {
lo = mid1 + 1;
}
}
return 0;
}
// Driver Code
const a = [2, 3, 6, 7, 9];
const b = [1, 4, 8, 10];
const k = 5;
console.log(kthElement(a, b, k));
Output
6