# K-th Element of Two Sorted Arrays

• Difficulty Level : Hard
• Last Updated : 10 Jun, 2022

Given two sorted arrays of size m and n respectively, you are tasked with finding the element that would be at the k’th position of the final sorted array.

Examples:

```Input : Array 1 - 2 3 6 7 9
Array 2 - 1 4 8 10
k = 5
Output : 6
Explanation: The final sorted array would be -
1, 2, 3, 4, 6, 7, 8, 9, 10
The 5th element of this array is 6.

Input : Array 1 - 100 112 256 349 770
Array 2 - 72 86 113 119 265 445 892
k = 7
Output : 256
Explanation: Final sorted array is -
72, 86, 100, 112, 113, 119, 256, 265, 349, 445, 770, 892
7th element of this array is 256.```

Basic Approach
Since we are given two sorted arrays, we can use the merging technique to get the final merged array. From this, we simply go to the k’th index.

## C++

 `// Program to find kth element from two sorted arrays``#include ``using` `namespace` `std;` `int` `kth(``int` `arr1[], ``int` `arr2[], ``int` `m, ``int` `n, ``int` `k)``{``    ``int` `sorted1[m + n];``    ``int` `i = 0, j = 0, d = 0;``    ``while` `(i < m && j < n)``    ``{``        ``if` `(arr1[i] < arr2[j])``            ``sorted1[d++] = arr1[i++];``        ``else``            ``sorted1[d++] = arr2[j++];``    ``}``    ``while` `(i < m)``        ``sorted1[d++] = arr1[i++];``    ``while` `(j < n)``        ``sorted1[d++] = arr2[j++];``    ``return` `sorted1[k - 1];``}` `// Driver Code``int` `main()``{``    ``int` `arr1 = {2, 3, 6, 7, 9};``    ``int` `arr2 = {1, 4, 8, 10};``    ``int` `k = 5;``    ``cout << kth(arr1, arr2, 5, 4, k);``    ``return` `0;``}`

## Java

 `// Java Program to find kth element``// from two sorted arrays` `class` `Main``{``    ``static` `int` `kth(``int` `arr1[], ``int` `arr2[], ``int` `m, ``int` `n, ``int` `k)``    ``{``        ``int``[] sorted1 = ``new` `int``[m + n];``        ``int` `i = ``0``, j = ``0``, d = ``0``;``        ``while` `(i < m && j < n)``        ``{``            ``if` `(arr1[i] < arr2[j])``                ``sorted1[d++] = arr1[i++];``            ``else``                ``sorted1[d++] = arr2[j++];``        ``}``        ``while` `(i < m)``            ``sorted1[d++] = arr1[i++];``        ``while` `(j < n)``            ``sorted1[d++] = arr2[j++];``        ``return` `sorted1[k - ``1``];``    ``}``    ` `    ``// Driver Code``    ``public` `static` `void` `main (String[] args)``    ``{``        ``int` `arr1[] = {``2``, ``3``, ``6``, ``7``, ``9``};``        ``int` `arr2[] = {``1``, ``4``, ``8``, ``10``};``        ``int` `k = ``5``;``        ``System.out.print(kth(arr1, arr2, ``5``, ``4``, k));``    ``}``}` `/* This code is contributed by Harsh Agarwal */`

## Python3

 `# Program to find kth element``# from two sorted arrays`  `def` `kth(arr1, arr2, m, n, k):` `    ``sorted1 ``=` `[``0``] ``*` `(m ``+` `n)``    ``i ``=` `0``    ``j ``=` `0``    ``d ``=` `0``    ``while` `(i < m ``and` `j < n):` `        ``if` `(arr1[i] < arr2[j]):``            ``sorted1[d] ``=` `arr1[i]``            ``i ``+``=` `1``        ``else``:``            ``sorted1[d] ``=` `arr2[j]``            ``j ``+``=` `1``        ``d ``+``=` `1` `    ``while` `(i < m):``        ``sorted1[d] ``=` `arr1[i]``        ``d ``+``=` `1``        ``i ``+``=` `1``    ``while` `(j < n):``        ``sorted1[d] ``=` `arr2[j]``        ``d ``+``=` `1``        ``j ``+``=` `1``    ``return` `sorted1[k ``-` `1``]`  `# Driver code``arr1 ``=` `[``2``, ``3``, ``6``, ``7``, ``9``]``arr2 ``=` `[``1``, ``4``, ``8``, ``10``]``k ``=` `5``print``(kth(arr1, arr2, ``5``, ``4``, k))` `# This code is contributed by Smitha Dinesh Semwal`

## C#

 `// C# Program to find kth element``// from two sorted arrays``class` `GFG {``    ``static` `int` `kth(``int``[] arr1, ``int``[] arr2, ``int` `m, ``int` `n,``                   ``int` `k)``    ``{``        ``int``[] sorted1 = ``new` `int``[m + n];``        ``int` `i = 0, j = 0, d = 0;``        ``while` `(i < m && j < n) {``            ``if` `(arr1[i] < arr2[j])``                ``sorted1[d++] = arr1[i++];``            ``else``                ``sorted1[d++] = arr2[j++];``        ``}``        ``while` `(i < m)``            ``sorted1[d++] = arr1[i++];``        ``while` `(j < n)``            ``sorted1[d++] = arr2[j++];``        ``return` `sorted1[k - 1];``    ``}` `    ``// Driver Code``    ``static` `void` `Main()``    ``{``        ``int``[] arr1 = { 2, 3, 6, 7, 9 };``        ``int``[] arr2 = { 1, 4, 8, 10 };``        ``int` `k = 5;``        ``System.Console.WriteLine(kth(arr1, arr2, 5, 4, k));``    ``}``}` `// This code is contributed by mits`

## PHP

 ``

## Javascript

 ``

Output

`6`

Time Complexity: O(n)
Auxiliary Space : O(m + n)

Space Optimized Version of above approach: We can avoid the use of extra array.

## C++

 `// C++ program to find kth element``// from two sorted arrays``#include ``using` `namespace` `std;` `int` `find(``int` `A[], ``int` `B[], ``int` `m,``         ``int` `n, ``int` `k_req)``{``    ``int` `k = 0, i = 0, j = 0;` `    ``// Keep taking smaller of the current``    ``// elements of two sorted arrays and``    ``// keep incrementing k``    ``while``(i < m && j < n)``    ``{``        ``if``(A[i] < B[j])``        ``{``            ``k++;``            ``if``(k == k_req)``                ``return` `A[i];``            ``i++;``        ``}``        ``else``        ``{``            ``k++;``            ``if``(k == k_req)``                ``return` `B[j];``            ``j++;``        ``}``    ``}` `    ``// If array B[] is completely traversed``    ``while``(i < m)``    ``{``        ``k++;``        ``if``(k == k_req)``            ``return` `A[i];``        ``i++;``    ``}` `    ``// If array A[] is completely traversed``    ``while``(j < n)``    ``{``        ``k++;``        ``if``(k == k_req)``            ``return` `B[j];``        ``j++;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `A = { 2, 3, 6, 7, 9 };``    ``int` `B = { 1, 4, 8, 10 };``    ``int` `k = 5;``    ` `    ``cout << find(A, B, 5, 4, k);``    ` `    ``return` `0;``}` `// This code is contributed by Sreejith S`

## Java

 `import` `java.io.*;` `class` `GFG {``    ``public` `static` `int` `find(``int` `A[], ``int` `B[], ``int` `m, ``int` `n,``                           ``int` `k_req)``    ``{``        ``int` `k = ``0``, i = ``0``, j = ``0``;` `        ``// Keep taking smaller of the current``        ``// elements of two sorted arrays and``        ``// keep incrementing k``        ``while` `(i < m && j < n) {``            ``if` `(A[i] < B[j]) {``                ``k++;``                ``if` `(k == k_req)``                    ``return` `A[i];``                ``i++;``            ``}``            ``else` `{``                ``k++;``                ``if` `(k == k_req)``                    ``return` `B[j];``                ``j++;``            ``}``        ``}` `        ``// If array B[] is completely traversed``        ``while` `(i < m) {``            ``k++;``            ``if` `(k == k_req)``                ``return` `A[i];``            ``i++;``        ``}` `        ``// If array A[] is completely traversed``        ``while` `(j < n) {``            ``k++;``            ``if` `(k == k_req)``                ``return` `B[j];``            ``j++;``        ``}``        ``return` `-``1``;``    ``}` `    ``// Driver Code``    ``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(find(A, B, ``5``, ``4``, k));``    ``}``}`

## Python3

 `# Python3 Program to find kth element``# from two sorted arrays` `def` `find(A, B, m, n, k_req):   ``    ``i, j, k ``=` `0``, ``0``, ``0` `    ``# Keep taking smaller of the current``    ``# elements of two sorted arrays and``    ``# keep incrementing k``    ``while` `i < ``len``(A) ``and` `j < ``len``(B):``        ``if` `A[i] < B[j]:``            ``k ``+``=` `1``            ``if` `k ``=``=` `k_req:``                ``return` `A[i]``            ``i ``+``=` `1``        ``else``:``            ``k ``+``=` `1``            ``if` `k ``=``=` `k_req:``                ``return` `B[j]       ``            ``j ``+``=` `1` `    ``# If array B[] is completely traversed``    ``while` `i < ``len``(A):``        ``k ``+``=` `1``        ``if` `k ``=``=` `k_req:``                ``return` `A[i]``        ``i ``+``=` `1`  `    ``# If array A[] is completely traversed``    ``while` `j < ``len``(B):``        ``k ``+``=` `1``        ``if` `k ``=``=` `k_req:``                ``return` `B[j]``        ``j ``+``=` `1` `# driver code``A ``=` `[``2``, ``3``, ``6``, ``7``, ``9``]``B ``=` `[``1``, ``4``, ``8``, ``10``]``k ``=` `5``;``print``(find(A, B, ``5``, ``4``, k))``# time complexity of O(k)`

## C#

 `// C# program to find kth element``// from two sorted arrays``using` `System;``public` `class` `GFG``{` `  ``public` `static` `int` `find(``int``[] A, ``int``[] B,``                         ``int` `m, ``int` `n,``int` `k_req)``  ``{``    ``int` `k = 0, i = 0, j = 0;` `    ``// Keep taking smaller of the current``    ``// elements of two sorted arrays and``    ``// keep incrementing k``    ``while` `(i < m && j < n) {``      ``if` `(A[i] < B[j]) {``        ``k++;``        ``if` `(k == k_req)``          ``return` `A[i];``        ``i++;``      ``}``      ``else` `{``        ``k++;``        ``if` `(k == k_req)``          ``return` `B[j];``        ``j++;``      ``}``    ``}` `    ``// If array B[] is completely traversed``    ``while` `(i < m)``    ``{``      ``k++;``      ``if` `(k == k_req)``        ``return` `A[i];``      ``i++;``    ``}` `    ``// If array A[] is completely traversed``    ``while` `(j < n)``    ``{``      ``k++;``      ``if` `(k == k_req)``        ``return` `B[j];``      ``j++;``    ``}``    ``return` `-1;``  ``}` `  ``// Driver Code``  ``static` `public` `void` `Main (){``    ``int``[] A = { 2, 3, 6, 7, 9 };``    ``int``[] B = { 1, 4, 8, 10 };``    ``int` `k = 5;``    ``Console.WriteLine(find(A, B, 5, 4, k));``  ``}``}` `// This code is contributed by rag2127`

## Javascript

 ``

Output

`6`

Time Complexity: O(k)
Auxiliary Space: O(1)

1. Divide And Conquer Approach 1
While the previous method works, can we make our algorithm more efficient? The answer is yes. By using a divide and conquer approach, similar to the one used in binary search, we can attempt to find the k’th element in a more efficient way.
2. Compare the middle elements of arrays arr1 and arr2, let us call these indices mid1 and mid2 respectively. Let us assume arr1[mid1]  k, then clearly the elements after mid2 cannot be the required element. Set the last element of arr2 to be arr2[mid2].
3. In this way, define a new subproblem with half the size of one of the arrays.

## C++

 `// Program to find k-th element from two sorted arrays``#include ``using` `namespace` `std;` `int` `kth(``int` `*arr1, ``int` `*arr2, ``int` `*end1, ``int` `*end2, ``int` `k)``{``    ``if` `(arr1 == end1)``        ``return` `arr2[k];``    ``if` `(arr2 == end2)``        ``return` `arr1[k];``    ``int` `mid1 = (end1 - arr1) / 2;``    ``int` `mid2 = (end2 - arr2) / 2;``    ``if` `(mid1 + mid2 < k)``    ``{``        ``if` `(arr1[mid1] > arr2[mid2])``            ``return` `kth(arr1, arr2 + mid2 + 1, end1, end2,``                ``k - mid2 - 1);``        ``else``            ``return` `kth(arr1 + mid1 + 1, arr2, end1, end2,``                ``k - mid1 - 1);``    ``}``    ``else``    ``{``        ``if` `(arr1[mid1] > arr2[mid2])``            ``return` `kth(arr1, arr2, arr1 + mid1, end2, k);``        ``else``            ``return` `kth(arr1, arr2, end1, arr2 + mid2, k);``    ``}``}` `int` `main()``{``    ``int` `arr1 = {2, 3, 6, 7, 9};``    ``int` `arr2 = {1, 4, 8, 10};` `    ``int` `k = 5;``    ``cout << kth(arr1, arr2, arr1 + 5, arr2 + 4,  k - 1);``    ``return` `0;``}`

## Python3

 `# Python program to find k-th element from two sorted arrays``def` `kth(arr1, arr2, n, m, k):` `    ``if` `n ``=``=` `1` `or` `m ``=``=` `1``:``        ``if` `m ``=``=` `1``:``            ``arr2, arr1 ``=` `arr1, arr2``            ``m ``=` `n``        ``if` `k ``=``=` `1``:``            ``return` `min``(arr1[``0``], arr2[``0``])``        ``elif` `k ``=``=` `m ``+` `1``:``            ``return` `max``(arr1[``0``], arr2[``0``])``        ``else``:``            ``if` `arr2[k ``-` `1``] < arr1[``0``]:``                ``return` `arr2[k ``-` `1``]``            ``else``:``                ``return` `max``(arr1[``0``], arr2[k ``-` `2``])` `    ``mid1 ``=` `(n ``-` `1``)``/``/``2``    ``mid2 ``=` `(m ``-` `1``)``/``/``2` `    ``if` `mid1``+``mid2``+``1` `< k:``        ``if` `arr1[mid1] < arr2[mid2]:``            ``return` `kth(arr1[mid1 ``+` `1``:], arr2, n ``-` `mid1 ``-` `1``, m, k ``-` `mid1 ``-` `1``)``        ``else``:``            ``return` `kth(arr1, arr2[mid2 ``+` `1``:], n, m ``-` `mid2 ``-` `1``, k ``-` `mid2 ``-` `1``)``    ``else``:``        ``if` `arr1[mid1] < arr2[mid2]:``            ``return` `kth(arr1, arr2[:mid2 ``+` `1``], n, mid2 ``+` `1``, k)``        ``else``:``            ``return` `kth(arr1[:mid1 ``+` `1``], arr2, mid1 ``+` `1``, m, k)`  `if` `__name__ ``=``=` `"__main__"``:``    ``arr1 ``=` `[``2``, ``3``, ``6``, ``7``, ``9``]``    ``arr2 ``=` `[``1``, ``4``, ``8``, ``10``]``    ``k ``=` `5``    ``print``(kth(arr1, arr2, ``5``, ``4``, k))` `# This code is contributed by harshitkap00r`

Output

`6`

Note that in the above code, k is 0 indexed, which means if we want a k that’s 1 indexed, we have to subtract 1 when passing it to the function.
Time Complexity: O(log n + log m)

Auxiliary Space: O(logn + logm)

Divide And Conquer Approach 2
While the above implementation is very efficient, we can still get away with making it more efficient. Instead of dividing the array into segments of n / 2 and m / 2 then recursing, we can divide them both by k / 2 and recurse. The below implementation displays this.

```Explanation:
Instead of comparing the middle element of the arrays,
we compare the k / 2nd element.
Let arr1 and arr2 be the arrays.
Now, if arr1[k / 2]  arr1

New subproblem:
Array 1 - 6 7 9
Array 2 - 1 4 8 10
k = 5 - 2 = 3

floor(k / 2) = 1
arr1 = 6
arr2 = 1
arr1 > arr2

New subproblem:
Array 1 - 6 7 9
Array 2 - 4 8 10
k = 3 - 1 = 2

floor(k / 2) = 1
arr1 = 6
arr2 = 4
arr1 > arr2

New subproblem:
Array 1 - 6 7 9
Array 2 - 8 10
k = 2 - 1 = 1

Now, we directly compare first elements,
since k = 1.
arr1 < arr2
Hence, arr1 = 6 is the answer.```

## C++

 `// C++ Program to find kth element from two sorted arrays``#include ``using` `namespace` `std;` `int` `kth(``int` `arr1[], ``int` `arr2[], ``int` `m, ``int` `n, ``int` `k,``                           ``int` `st1 = 0, ``int` `st2 = 0)``{``    ``// In case we have reached end of array 1``    ``if` `(st1 == m)``        ``return` `arr2[st2 + k - 1];` `    ``// In case we have reached end of array 2``    ``if` `(st2 == n)``        ``return` `arr1[st1 + k - 1];` `    ``// k should never reach 0 or exceed sizes``    ``// of arrays``    ``if` `(k == 0 || k > (m - st1) + (n - st2))``        ``return` `-1;` `    ``// Compare first elements of arrays and return``    ``if` `(k == 1)``        ``return` `(arr1[st1] < arr2[st2]) ?``            ``arr1[st1] : arr2[st2];``    ``int` `curr = k / 2;` `    ``// Size of array 1 is less than k / 2``    ``if` `(curr - 1 >= m - st1)``    ``{``        ``// Last element of array 1 is not kth``        ``// We can directly return the (k - m)th``        ``// element in array 2``        ``if` `(arr1[m - 1] < arr2[st2 + curr - 1])``            ``return` `arr2[st2 + (k - (m - st1) - 1)];``        ``else``            ``return` `kth(arr1, arr2, m, n, k - curr,``                ``st1, st2 + curr);``    ``}` `    ``// Size of array 2 is less than k / 2``    ``if` `(curr-1 >= n-st2)``    ``{``        ``if` `(arr2[n - 1] < arr1[st1 + curr - 1])``            ``return` `arr1[st1 + (k - (n - st2) - 1)];``        ``else``            ``return` `kth(arr1, arr2, m, n, k - curr,``                ``st1 + curr, st2);``    ``}``    ``else``    ``{``        ``// Normal comparison, move starting index``        ``// of one array k / 2 to the right``        ``if` `(arr1[curr + st1 - 1] < arr2[curr + st2 - 1])``            ``return` `kth(arr1, arr2, m, n, k - curr,``                ``st1 + curr, st2);``        ``else``            ``return` `kth(arr1, arr2, m, n, k - curr,``                ``st1, st2 + curr);``    ``}``}` `// Driver code``int` `main()``{``    ``int` `arr1 = {2, 3, 6, 7, 9};``    ``int` `arr2 = {1, 4, 8, 10};` `    ``int` `k = 5;``    ``cout << kth(arr1, arr2, 5, 4,  k);``    ``return` `0;``}`

## Java

 `// Java Program to find kth element from two sorted arrays``class` `GFG``{` `    ``static` `int` `kth(``int` `arr1[], ``int` `arr2[], ``int` `m,``                   ``int` `n, ``int` `k, ``int` `st1, ``int` `st2)``    ``{``        ``// In case we have reached end of array 1``        ``if` `(st1 == m)``        ``{``            ``return` `arr2[st2 + k - ``1``];``        ``}` `        ``// In case we have reached end of array 2``        ``if` `(st2 == n)``        ``{``            ``return` `arr1[st1 + k - ``1``];``        ``}` `        ``// k should never reach 0 or exceed sizes``        ``// of arrays``        ``if` `(k == ``0` `|| k > (m - st1) + (n - st2))``        ``{``            ``return` `-``1``;``        ``}` `        ``// Compare first elements of arrays and return``        ``if` `(k == ``1``)``        ``{``            ``return` `(arr1[st1] < arr2[st2])``                    ``? arr1[st1] : arr2[st2];``        ``}``        ``int` `curr = k / ``2``;` `        ``// Size of array 1 is less than k / 2``        ``if` `(curr - ``1` `>= m - st1)``        ``{``            ` `            ``// Last element of array 1 is not kth``            ``// We can directly return the (k - m)th``            ``// element in array 2``            ``if` `(arr1[m - ``1``] < arr2[st2 + curr - ``1``])``            ``{``                ``return` `arr2[st2 + (k - (m - st1) - ``1``)];``            ``}``            ``else``            ``{``                ``return` `kth(arr1, arr2, m, n, k - curr,``                        ``st1, st2 + curr);``            ``}``        ``}` `        ``// Size of array 2 is less than k / 2``        ``if` `(curr - ``1` `>= n - st2)``        ``{``            ``if` `(arr2[n - ``1``] < arr1[st1 + curr - ``1``])``            ``{``                ``return` `arr1[st1 + (k - (n - st2) - ``1``)];``            ``}``            ``else``            ``{``                ``return` `kth(arr1, arr2, m, n, k - curr,``                        ``st1 + curr, st2);``            ``}``        ``}``        ``else``        ` `        ``// Normal comparison, move starting index``        ``// of one array k / 2 to the right``        ``if` `(arr1[curr + st1 - ``1``] < arr2[curr + st2 - ``1``])``        ``{``            ``return` `kth(arr1, arr2, m, n, k - curr,``                    ``st1 + curr, st2);``        ``}``        ``else``        ``{``            ``return` `kth(arr1, arr2, m, n, k - curr,``                    ``st1, st2 + curr);``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr1[] = {``2``, ``3``, ``6``, ``7``, ``9``};``        ``int` `arr2[] = {``1``, ``4``, ``8``, ``10``};``        ``int` `k = ``5``;``        ``int` `st1 = ``0``, st2 = ``0``;``        ``System.out.println(kth(arr1, arr2, ``5``, ``4``, k, st1, st2));``    ``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program to find kth element from``# two sorted arrays``def` `kth(arr1, arr2, m, n, k, st1 ``=` `0``, st2 ``=` `0``):``    ` `    ``# In case we have reached end of array 1``    ``if` `(st1 ``=``=` `m):``        ``return` `arr2[st2 ``+` `k ``-` `1``]` `    ``# In case we have reached end of array 2``    ``if` `(st2 ``=``=` `n):``        ``return` `arr1[st1 ``+` `k ``-` `1``]` `    ``# k should never reach 0 or exceed sizes``    ``# of arrays``    ``if` `(k ``=``=` `0` `or` `k > (m ``-` `st1) ``+` `(n ``-` `st2)):``        ``return` `-``1``        ` `    ``# Compare first elements of arrays and return``    ``if` `(k ``=``=` `1``):``        ``if``(arr1[st1] < arr2[st2]):``            ``return` `arr1[st1]``        ``else``:``            ``return` `arr2[st2]` `    ``curr ``=` `int``(k ``/` `2``)` `    ``# Size of array 1 is less than k / 2``    ``if``(curr ``-` `1` `>``=` `m ``-` `st1):` `        ``# Last element of array 1 is not kth``        ``# We can directly return the (k - m)th``        ``# element in array 2``        ``if` `(arr1[m ``-` `1``] < arr2[st2 ``+` `curr ``-` `1``]):``            ``return` `arr2[st2 ``+` `(k ``-` `(m ``-` `st1) ``-` `1``)]``        ``else``:``            ``return` `kth(arr1, arr2, m, n,``                       ``k ``-` `curr, st1, st2 ``+` `curr)` `    ``# Size of array 2 is less than k / 2``    ``if` `(curr ``-` `1` `>``=` `n ``-` `st2):``        ``if` `(arr2[n ``-` `1``] < arr1[st1 ``+` `curr ``-` `1``]):``            ``return` `arr1[st1 ``+` `(k ``-` `(n ``-` `st2) ``-` `1``)]``        ``else``:``            ``return` `kth(arr1, arr2, m, n,``                       ``k ``-` `curr,st1 ``+` `curr, st2)``    ``else``:``        ` `        ``# Normal comparison, move starting index``        ``# of one array k / 2 to the right``        ``if` `(arr1[curr ``+` `st1 ``-` `1``] < arr2[curr ``+` `st2 ``-` `1``]):``            ``return` `kth(arr1, arr2, m, n, k ``-` `curr,``                       ``st1 ``+` `curr, st2)``        ``else``:``            ``return` `kth(arr1, arr2, m, n, k ``-` `curr,``                       ``st1, st2 ``+` `curr)` `# Driver code``arr1 ``=` `[ ``2``, ``3``, ``6``, ``7``, ``9` `]``arr2 ``=` `[ ``1``, ``4``, ``8``, ``10` `]``k ``=` `5` `print``(kth(arr1, arr2, ``5``, ``4``, k))` `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# Program to find kth element from two sorted arrays``using` `System;` `class` `GFG``{` `    ``static` `int` `kth(``int` `[]arr1, ``int` `[]arr2, ``int` `m,``                ``int` `n, ``int` `k, ``int` `st1, ``int` `st2)``    ``{``        ``// In case we have reached end of array 1``        ``if` `(st1 == m)``        ``{``            ``return` `arr2[st2 + k - 1];``        ``}` `        ``// In case we have reached end of array 2``        ``if` `(st2 == n)``        ``{``            ``return` `arr1[st1 + k - 1];``        ``}` `        ``// k should never reach 0 or exceed sizes``        ``// of arrays``        ``if` `(k == 0 || k > (m - st1) + (n - st2))``        ``{``            ``return` `-1;``        ``}` `        ``// Compare first elements of arrays and return``        ``if` `(k == 1)``        ``{``            ``return` `(arr1[st1] < arr2[st2])``                    ``? arr1[st1] : arr2[st2];``        ``}``        ``int` `curr = k / 2;` `        ``// Size of array 1 is less than k / 2``        ``if` `(curr - 1 >= m - st1)``        ``{``            ` `            ``// Last element of array 1 is not kth``            ``// We can directly return the (k - m)th``            ``// element in array 2``            ``if` `(arr1[m - 1] < arr2[st2 + curr - 1])``            ``{``                ``return` `arr2[st2 + (k - (m - st1) - 1)];``            ``}``            ``else``            ``{``                ``return` `kth(arr1, arr2, m, n, k - curr,``                        ``st1, st2 + curr);``            ``}``        ``}` `        ``// Size of array 2 is less than k / 2``        ``if` `(curr - 1 >= n - st2)``        ``{``            ``if` `(arr2[n - 1] < arr1[st1 + curr - 1])``            ``{``                ``return` `arr1[st1 + (k - (n - st2) - 1)];``            ``}``            ``else``            ``{``                ``return` `kth(arr1, arr2, m, n, k - curr,``                        ``st1 + curr, st2);``            ``}``        ``}``        ``else``        ` `        ``// Normal comparison, move starting index``        ``// of one array k / 2 to the right``        ``if` `(arr1[curr + st1 - 1] < arr2[curr + st2 - 1])``        ``{``            ``return` `kth(arr1, arr2, m, n, k - curr,``                    ``st1 + curr, st2);``        ``}``        ``else``        ``{``            ``return` `kth(arr1, arr2, m, n, k - curr,``                    ``st1, st2 + curr);``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int` `[]arr1 = {2, 3, 6, 7, 9};``        ``int` `[]arr2 = {1, 4, 8, 10};``        ``int` `k = 5;``        ``int` `st1 = 0, st2 = 0;``        ``Console.WriteLine(kth(arr1, arr2, 5, 4, k, st1, st2));``    ``}``}` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output

`6`

Time Complexity: O(log k)

Auxiliary Space: O(logk)

Now, k can take a maximum value of m + n. This means that log k can be in the worst case, log(m + n). Logm + logn = log(mn) by properties of logarithms, and when m, n > 2, log(m + n) < log(mn). Thus this algorithm slightly outperforms the previous algorithm. Also, see another simple implemented log k approach suggested by Raj Kumar.

## C++

 `// C++ Program to find kth``// element from two sorted arrays``// Time Complexity: O(log k)` `#include ``using` `namespace` `std;` `int` `kth(``int` `arr1[], ``int` `m, ``int` `arr2[], ``int` `n, ``int` `k)``{` `    ``if` `(k > (m + n) || k < 1)``        ``return` `-1;` `    ``// let m <= n``    ``if` `(m > n)``        ``return` `kth(arr2, n, arr1, m, k);` `    ``// Check if arr1 is empty returning``    ``// k-th element of arr2``    ``if` `(m == 0)``        ``return` `arr2[k - 1];` `    ``// Check if k = 1 return minimum of``    ``// first two elements of both``    ``// arrays``    ``if` `(k == 1)``        ``return` `min(arr1, arr2);` `    ``// Now the divide and conquer part``    ``int` `i = min(m, k / 2), j = min(n, k / 2);` `    ``if` `(arr1[i - 1] > arr2[j - 1])``      ` `        ``// Now we need to find only``        ``// k-j th element since we``        ``// have found out the lowest j``        ``return` `kth(arr1, m, arr2 + j, n - j, k - j);``    ``else``      ` `        ``// Now we need to find only``        ``// k-i th element since we``        ``// have found out the lowest i``        ``return` `kth(arr1 + i, m - i, arr2, n, k - i);``}` `// Driver code``int` `main()``{``    ``int` `arr1 = { 2, 3, 6, 7, 9 };``    ``int` `arr2 = { 1, 4, 8, 10 };``    ``int` `m = ``sizeof``(arr1) / ``sizeof``(arr1);``    ``int` `n = ``sizeof``(arr2) / ``sizeof``(arr2);``    ``int` `k = 5;` `    ``int` `ans = kth(arr1, m, arr2, n, k);` `    ``if` `(ans == -1)``        ``cout << ``"Invalid query"``;``    ``else``        ``cout << ans;` `    ``return` `0;``}``// This code is contributed by Raj Kumar`

## Java

 `// Java Program to find kth element``// from two sorted arrays``// Time Complexity: O(log k)``import` `java.util.Arrays;` `class` `Gfg {``    ``static` `int` `kth(``int` `arr1[], ``int` `m, ``int` `arr2[], ``int` `n,``                   ``int` `k)``    ``{``        ``if` `(k > (m + n) || k < ``1``)``            ``return` `-``1``;` `        ``// let m > n``        ``if` `(m > n)``            ``return` `kth(arr2, n, arr1, m, k);` `        ``// Check if arr1 is empty returning``        ``// k-th element of arr2``        ``if` `(m == ``0``)``            ``return` `arr2[k - ``1``];` `        ``// Check if k = 1 return minimum of first``        ``// two elements of both arrays``        ``if` `(k == ``1``)``            ``return` `Math.min(arr1[``0``], arr2[``0``]);` `        ``// Now the divide and conquer part``        ``int` `i = Math.min(m, k / ``2``);``        ``int` `j = Math.min(n, k / ``2``);` `        ``if` `(arr1[i - ``1``] > arr2[j - ``1``]) {``          ` `            ``// Now we need to find only k-j th element``            ``// since we have found out the lowest j``            ``int` `temp[] = Arrays.copyOfRange(arr2, j, n);``            ``return` `kth(arr1, m, temp, n - j, k - j);``        ``}` `        ``// Now we need to find only k-i th element``        ``// since we have found out the lowest i``        ``int` `temp[] = Arrays.copyOfRange(arr1, i, m);``        ``return` `kth(temp, m - i, arr2, n, k - i);``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr1[] = { ``2``, ``3``, ``6``, ``7``, ``9` `};``        ``int` `arr2[] = { ``1``, ``4``, ``8``, ``10` `};``        ``int` `m = arr1.length;``        ``int` `n = arr2.length;` `        ``int` `k = ``5``;``        ``int` `ans = kth(arr1, m, arr2, n, k);``        ``if` `(ans == -``1``)``            ``System.out.println(``"Invalid query"``);``        ``else``            ``System.out.println(ans);``    ``}``}` `// This code is contributed by Vivek Kumar Singh`

## Python3

 `# Python3 Program to find kth element from two``# sorted arrays. Time Complexity: O(log k)``def` `kth(arr1, m, arr2, n, k):``    ` `    ``if` `(k > (m ``+` `n) ``or` `k < ``1``):``        ``return` `-``1``    ` `    ``# Let m <= n``    ``if` `(m > n):``        ``return` `kth(arr2, n, arr1, m, k)``    ` `    ``# Check if arr1 is empty returning``    ``# k-th element of arr2``    ``if` `(m ``=``=` `0``):``        ``return` `arr2[k ``-` `1``]``    ` `    ``# Check if k = 1 return minimum of``    ``# first two elements of both``    ``# arrays``    ``if` `(k ``=``=` `1``):``        ``return` `min``(arr1[``0``], arr2[``0``])``        ` `    ``# Now the divide and conquer part``    ``i ``=` `min``(m, k ``/``/` `2``)``    ``j ``=` `min``(n, k ``/``/` `2``)``    ` `    ``if` `(arr1[i ``-` `1``] > arr2[j ``-` `1``]):``        ` `        ``# Now we need to find only``        ``# k-j th element since we``        ``# have found out the lowest j``        ``return` `kth(arr1, m, arr2[j:], n ``-` `j, k ``-` `j)``    ``else``:``        ` `        ``# Now we need to find only``        ``# k-i th element since we``        ``# have found out the lowest i``        ``return` `kth(arr1[i:], m ``-` `i, arr2, n, k ``-` `i)` `# Driver code``arr1 ``=` `[ ``2``, ``3``, ``6``, ``7``, ``9` `]``arr2 ``=` `[ ``1``, ``4``, ``8``, ``10` `]``m ``=` `len``(arr1)``n ``=` `len``(arr2)``k ``=` `5` `ans ``=` `kth(arr1, m, arr2, n, k)` `if` `(ans ``=``=` `-``1``):``    ``print``(``"Invalid query"``)``else``:``    ``print``(ans)` `# This code is contributed by Shubham Singh`

## C#

 `// C# Program to find kth element``// from two sorted arrays``// Time Complexity: O(log k)``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG{` `  ``static` `int` `kth(``int``[] arr1, ``int` `m, ``int``[] arr2, ``int` `n,``                 ``int` `k)``  ``{``    ``if` `(k > (m + n) || k < 1)``      ``return` `-1;` `    ``// let m > n``    ``if` `(m > n)``      ``return` `kth(arr2, n, arr1, m, k);` `    ``// Check if arr1 is empty returning``    ``// k-th element of arr2``    ``if` `(m == 0)``      ``return` `arr2[k - 1];` `    ``// Check if k = 1 return minimum of first``    ``// two elements of both arrays``    ``if` `(k == 1)``      ``return` `Math.Min(arr1, arr2);` `    ``// Now the divide and conquer part``    ``int` `i = Math.Min(m, k / 2);``    ``int` `j = Math.Min(n, k / 2);` `    ``if` `(arr1[i - 1] > arr2[j - 1]) {` `      ``// Now we need to find only k-j th element``      ``// since we have found out the lowest j``      ``int``[] temp = ``new` `int``[n - j];``      ``Array.Copy(arr2, j, temp, 0, n-j);` `      ``return` `kth(arr1, m, temp, n - j, k - j);``    ``}` `    ``// Now we need to find only k-i th element``    ``// since we have found out the lowest i``    ``int``[] temp1 = ``new` `int``[m-i];``    ``Array.Copy(arr1, i, temp1, 0, m-i);` `    ``return` `kth(temp1, m - i, arr2, n, k - i);``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main()``  ``{``    ``int``[] arr1 = { 2, 3, 6, 7, 9 };``    ``int``[] arr2 = { 1, 4, 8, 10 };``    ``int` `m = arr1.Length;``    ``int` `n = arr2.Length;` `    ``int` `k = 5;``    ``int` `ans = kth(arr1, m, arr2, n, k);``    ``if` `(ans == -1)``      ``Console.WriteLine(``"Invalid query"``);``    ``else``      ``Console.WriteLine(ans);``  ``}``}` `// This code is contributed by Shubham Singh`

## Javascript

 ``

Output

`6`

Time Complexity:O(log k)

Auxiliary Space: O(log k)

Another Approach: (Using Min Heap)

1. Push the elements of both arrays to a priority queue (min-heap).
2. Pop-out k-1 elements from the front.
3. Element at the front of the priority queue is the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ Program to find kth``// element from two sorted arrays``#include ``using` `namespace` `std;` `// Function to find K-th min``int` `kth(``int``* a, ``int``* b, ``int` `n, ``int` `m, ``int` `k)``{``      ``// Declaring a min heap``    ``priority_queue<``int``, vector<``int``>,``                   ``greater<``int``> > pq;``      ` `      ``// Pushing elements for``    ``// array a to min-heap``    ``for` `(``int` `i = 0; i < n; i++) {``        ``pq.push(a[i]);``    ``}``  ` `      ``// Pushing elements for``    ``// array b to min-heap``    ``for` `(``int` `i = 0; i < m; i++) {``        ``pq.push(b[i]);``    ``}``  ` `      ``// Popping-out K-1 elements``    ``while` `(k-- > 1) {``        ``pq.pop();``    ``}``    ``return` `pq.top();``}` `//Driver Code``int` `main()``{``    ``int` `arr1 = {2, 3, 6, 7, 9};``    ``int` `arr2 = {1, 4, 8, 10};``    ``int` `k = 5;``    ``cout << kth(arr1, arr2, 5, 4, k);``    ``return` `0;``}` `// This code is contributed by yashbeersingh42`

## Java

 `// Java Program to find kth element``// from two sorted arrays``import` `java.util.*;` `class` `GFG {``  ` `    ``// Function to find K-th min``    ``static` `int` `kth(``int` `a[], ``int` `b[],``                   ``int` `n, ``int` `m, ``int` `k)``    ``{``        ` `        ``// Declaring a min heap``        ``PriorityQueue pq =``                        ``new` `PriorityQueue<>();` `        ``// Pushing elements for``        ``// array a to min-heap``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``pq.offer(a[i]);``        ``}` `        ``// Pushing elements for``        ``// array b to min-heap``        ``for` `(``int` `i = ``0``; i < m; i++) {``            ``pq.offer(b[i]);``        ``}` `        ``// Popping-out K-1 elements``        ``while` `(k-- > ``1``) {``            ``pq.remove();``        ``}``        ``return` `pq.peek();``    ``}``  ` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr1[] = { ``2``, ``3``, ``6``, ``7``, ``9` `};``        ``int` `arr2[] = { ``1``, ``4``, ``8``, ``10` `};``        ``int` `k = ``5``;``        ``System.out.print(kth(arr1, arr2, ``5``, ``4``, k));``    ``}``}` `// This code is contributed by yashbeersingh42`

## Python3

 `# Python Program to find kth element``# from two sorted arrays` `# Function to find K-th min``def` `kth(a , b , n , m , k):` `    ``# Declaring a min heap``    ``pq ``=` `[];` `    ``# Pushing elements for``    ``# array a to min-heap``    ``for` `i ``in` `range``(n):``        ``pq.append(a[i]);` `    ``# Pushing elements for``    ``# array b to min-heap``    ``for` `i ``in` `range``(m):``        ``pq.append(b[i]);` `    ``pq ``=` `sorted``(pq, reverse ``=` `True``)``    ` `    ``# Popping-out K-1 elements``    ``while` `(k > ``1``):``        ``k ``-``=` `1``;``        ``pq.pop();``    ``return` `pq.pop();` `# Driver Code``arr1 ``=` `[ ``2``, ``3``, ``6``, ``7``, ``9` `];``arr2 ``=` `[ ``1``, ``4``, ``8``, ``10` `];``k ``=` `5``;``print``(kth(arr1, arr2, ``5``, ``4``, k));` `# This code is contributed by Saurabh Jaiswal`

## C#

 `// C# Program to find kth element``// from two sorted arrays``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG {` `  ``// Function to find K-th min``  ``static` `int` `kth(``int` `[]a, ``int` `[]b, ``int` `n, ``int` `m, ``int` `k) {` `    ``// Declaring a min heap``    ``List<``int``> pq = ``new` `List<``int``>();` `    ``// Pushing elements for``    ``// array a to min-heap``    ``for` `(``int` `i = 0; i < n; i++) {``      ``pq.Add(a[i]);``    ``}` `    ``// Pushing elements for``    ``// array b to min-heap``    ``for` `(``int` `i = 0; i < m; i++) {``      ``pq.Add(b[i]);``    ``}``    ``pq.Sort();``    ``// Popping-out K-1 elements``    ``while` `(k-- > 1) {``      ``pq.RemoveAt(0);``    ``}``    ``return` `pq;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(String[] args) {``    ``int` `[]arr1 = { 2, 3, 6, 7, 9 };``    ``int` `[]arr2 = { 1, 4, 8, 10 };``    ``int` `k = 5;``    ``Console.Write(kth(arr1, arr2, 5, 4, k));``  ``}``}` `// This code is contributed by gauravrajput1`

## Javascript

 ``

Output

`6`

Time Complexity: O(NlogN)

Auxiliary Space: O(m+n)

Another Approach : (Using Upper Bound STL)

Given two sorted arrays of size m and n respectively, you are tasked with finding the element that would be at the k’th position of the final sorted array.

Examples :

Input : Array 1 – 2 3 6 7 9

Array 2 – 1 4 8 10

k = 5

Output : 6

Explanation: The final sorted array would be –

1, 2, 3, 4, 6, 7, 8, 9, 10

The 5th element of this array is 6, The 1st element of this array is 1. The thing to notice here is upper_bound(6) gives 5, upper_bound(4) gives 4 that is number of element equal to or less than the number we are giving as input to upper_bound().

Here is another example

Input : Array 1 – 100 112 256 349 770

Array 2 – 72 86 113 119 265 445 892

k = 7

Output : 256

Explanation: Final sorted array is –

72, 86, 100, 112, 113, 119, 256, 265, 349, 445, 770, 892

7th element of this array is 256.

Observation required :

The simplest method to solve this question is using upper_bound to check what is the position of a element in the sorted array. The upper_bound function return the pointer to element which is greater than the element we searched.

So to find the kth element we need to just find the element whose upper_bound() is 4. So again now we now what upper_bound() gives us we need 1 last observation to solve this question. If we have been given 2 arrays, We just need to the sum of upper_bound for the 2 arrays

Input : Array 1 – 2 3 6 7 9

Array 2 – 1 4 8 10

k = 5

Value of upper_bound for value(6) in array1 is 3 and for array 2 is 2. This give us a total of 5. which is the answer.

Algorithm :

• We take a mid between [L,R] using the formula mid = (L+R)/2.
• Check if the middle can be the kth element using upper_bound() function
• Find the sum of upper_bound() for both the arrays and if the sum is >= K, It’s a possible value of kth element.
• If sum is >= K then we assign R = mid – 1.
• else if sum <k then the current mid is too small and we assign L = mid+1.
• Repeat from top
• Return the smallest value found.

Here is the implementation for the optimized method :

## C++

 `// C++ program to find the kth element``#include ``using` `namespace` `std;` `long` `long` `int` `maxN``    ``= 1e10; ``// the maximum value in the array possible.` `long` `long` `int` `kthElement(``int` `arr1[], ``int` `arr2[], ``int` `n,``                         ``int` `m, ``int` `k)``{``    ``long` `long` `int` `left = 1,``                  ``right``                  ``= maxN; ``// The range of where ans can lie.``    ``long` `long` `int` `ans = 1e15; ``// We have to find min of all``                              ``// the ans so take .` `    ``// using binary search to check all possible values of``    ``// kth element``    ``while` `(left <= right) {``        ``long` `long` `int` `mid = (left + right) / 2;``        ``long` `long` `int` `up_cnt``            ``= upper_bound(arr1, arr1 + n, mid) - arr1;``        ``up_cnt += upper_bound(arr2, arr2 + m, mid) - arr2;` `        ``if` `(up_cnt >= k) {``            ``ans = min(ans,``                      ``mid); ``// find the min of all answers.``            ``right``                ``= mid - 1; ``// Try to find a smaller answer.``        ``}``        ``else``            ``left = mid + 1; ``// Current mid is too small so``                            ``// shift right.``    ``}` `    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``// Example 1``    ``int` `n = 5, m = 7, k = 7;``    ``int` `arr1[n] = { 100, 112, 256, 349, 770 };``    ``int` `arr2[m] = { 72, 86, 113, 119, 265, 445, 892 };``    ``cout << kthElement(arr1, arr2, n, m, k) << endl;``    ``return` `0;``}`

## Java

 `// Java program to find the kth element``import` `java.util.*;``class` `GFG{` `static` `long`  `maxN = (``long``)1e10; ``// the maximum value in the array possible.` `static` `int` `upperBound(``int``[] a, ``int` `low,``                      ``int` `high, ``long` `element)``{``    ``while``(low < high){``        ``int` `middle = low + (high - low)/``2``;``        ``if``(a[middle] > element)``            ``high = middle;``        ``else``            ``low = middle + ``1``;``    ``}``    ``return` `low;``}` `static` `long`  `kthElement(``int` `arr1[], ``int` `arr2[], ``int` `n,``                         ``int` `m, ``int` `k)``{``    ``long`  `left = ``1``, right = maxN; ``// The range of where ans can lie.``    ``long`  `ans = (``long``)1e15; ``// We have to find min of all``                              ``// the ans so take .` `    ``// using binary search to check all possible values of``    ``// kth element``    ``while` `(left <= right) {``        ``long`  `mid = (left + right) / ``2``;``        ``long`  `up_cnt = upperBound(arr1,``0``, n, mid);``        ``up_cnt += upperBound(arr2, ``0``, m, mid);` `        ``if` `(up_cnt >= k) {``            ``ans = Math.min(ans,``                      ``mid); ``// find the min of all answers.``            ``right``                ``= mid - ``1``; ``// Try to find a smaller answer.``        ``}``        ``else``            ``left = mid + ``1``; ``// Current mid is too small so``                            ``// shift right.``    ``}` `    ``return` `ans;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``// Example 1``    ``int` `n = ``5``, m = ``7``, k = ``7``;``    ``int` `arr1[] = { ``100``, ``112``, ``256``, ``349``, ``770` `};``    ``int` `arr2[] = { ``72``, ``86``, ``113``, ``119``, ``265``, ``445``, ``892` `};``    ``System.out.print(kthElement(arr1, arr2, n, m, k) +``"\n"``);``}``}` `// This code is contributed by gauravrajput1`

## Python3

 `# Python program to find the kth element``maxN ``=` `10``*``*``10` `# the maximum value in the array possible.` `def` `upperBound(a, low, high, element):``    ``while``(low < high):``        ``middle ``=` `low ``+` `(high ``-` `low)``/``/``2``        ``if``(a[middle] > element):``            ``high ``=` `middle``        ``else``:``            ``low ``=` `middle ``+` `1``    ``return` `low` `def` `kthElement(arr1, arr2, n, m, k):``    ``left ``=` `1``    ``right ``=` `maxN ``# The range of where ans can lie.``    ``ans ``=` `10``*``*``15` `# We have to find min of all``    ``# the ans so take .``    ` `    ``# using binary search to check all possible values of``    ``# kth element``    ``while` `(left <``=` `right):``        ``mid ``=` `(left ``+` `right) ``/``/` `2``        ``up_cnt ``=` `upperBound(arr1,``0``, n, mid)``        ``up_cnt ``+``=` `upperBound(arr2, ``0``, m, mid)``        ` `        ``if` `(up_cnt >``=` `k):``            ``ans ``=` `min``(ans, mid) ``# find the min of all answers.``            ``right``=` `mid ``-` `1` `# Try to find a smaller answer.``        ``else``:``            ``left ``=` `mid ``+` `1` `# Current mid is too small so``            ``# shift right.``    ``return` `ans` `# Driver code``# Example 1``n ``=` `5``m ``=` `7``k ``=` `7``arr1 ``=` `[``100``, ``112``, ``256``, ``349``, ``770``]``arr2 ``=` `[``72``, ``86``, ``113``, ``119``, ``265``, ``445``, ``892``]``print``(kthElement(arr1, arr2, n, m, k))` `# This code is contributed by Shubham Singh`

## C#

 `// C# program to find the kth element` `using` `System;` `public` `class` `GFG{` `    ``static` `long`  `maxN = (``long``)1e10; ``// the maximum value in the array possible.``    ` `    ``static` `int` `upperBound(``int``[] a, ``int` `low,``                          ``int` `high, ``long` `element)``    ``{``        ``while``(low < high){``            ``int` `middle = low + (high - low)/2;``            ``if``(a[middle] > element)``                ``high = middle;``            ``else``                ``low = middle + 1;``        ``}``        ``return` `low;``    ``}``    ` `    ``static` `long`  `kthElement(``int``[] arr1, ``int``[] arr2, ``int` `n,``                             ``int` `m, ``int` `k)``    ``{``        ``long`  `left = 1, right = maxN; ``// The range of where ans can lie.``        ``long`  `ans = (``long``)1e15; ``// We have to find min of all``                                  ``// the ans so take .``    ` `        ``// using binary search to check all possible values of``        ``// kth element``        ``while` `(left <= right) {``            ``long`  `mid = (left + right) / 2;``            ``long`  `up_cnt = upperBound(arr1,0, n, mid);``            ``up_cnt += upperBound(arr2, 0, m, mid);``    ` `            ``if` `(up_cnt >= k) {``                ``ans = Math.Min(ans,``                          ``mid); ``// find the min of all answers.``                ``right``                    ``= mid - 1; ``// Try to find a smaller answer.``            ``}``            ``else``                ``left = mid + 1; ``// Current mid is too small so``                                ``// shift right.``        ``}``    ` `        ``return` `ans;``    ``}``    ` `    ``// Driver code``    ``static` `public` `void` `Main (){``        ``// Example 1``        ``int` `n = 5, m = 7, k = 7;``        ``int``[] arr1 = { 100, 112, 256, 349, 770 };``        ``int``[] arr2 = { 72, 86, 113, 119, 265, 445, 892 };``        ``Console.Write(kthElement(arr1, arr2, n, m, k) +``"\n"``);``    ``}``}` `// This code is contributed by SHubham Singh`

## Javascript

 ``

Output

`256`

Time Complexity : O( Log( maxN ).log( N+M ) )
Auxiliary Space : O( 1 )