Find Nth element from the two unsorted Array - arrays

Question

Given two unsorted int arrays, find the kth element in the merged, sorted array.
example:
int[] a= [3 1 7]
int[] b = [4 9]
k: 3
return 4 (non-Zero based index)
Please do not provide the straight forward solution where merge two array and sort and find the Nth element. I am looking for more efficient solution i.e using Heap, QuickSort. and make sure arrays are unsorted.
P.S: I know there are many similar questions of above posted in SO but i couldn't find any correct way of implementation in any of them.

Answer 1

As it stands your example is wrong.
Assuming its int[] a= [3 1 7] int[] b = [4 9] k: 3 return 7.
Loop through both arrays and push to a min-heap. After your done, pop k times from the heap and you will have the kth (largest) element from the merged array.
PriorityQueue<Integer> minHeap=new PriorityQueue();
for (Integer i : a)
{
minHeap.add(i);
}
for (Integer i : b)
{
minHeap.add(i);
}
int count=1;// 1 based index
while(!minHeap.isEmpty())
{
Integer head=minHeap.poll();
count++;
if(count==k)
return head;
}
Code above is untested. But it should roughly look like the above.

Answer 2

The general term for this problem is Selection Algorithm, which Wikipedia has a great article on.
Finding the kth element of two unsorted arrays is equivalent to finding the kth element of one--just pretend you've concatenated the two. A simple algorithm from the linked page is Quickselect, which is essentially Quicksort but only recursing into the half that contains the kth element. Essentially,
Use the first element as the pivot
Iterate over the array, assigning items <= to the pivot to one array, and > to another, until an array has grown large enough that it must contain the desired element
Recurse on that array, offsetting k if necessary

Answer 3

C# code using quick select algorithm:
private void MergeUnsortedArray(int[] A1, int[] A2)
{
int[] c = new int[A1.Length + A2.Length];
int length = 0;
for (int i = 0; i < A1.Length; i++)
{
c[i] = A2[i];
length++;
}
for (int j = 0; j < A2.Length; j++)
{
c[length + j + 1] = A2[j];
}
quickselect(c, 0, c.Length, 3);
}
private int quickselect(int[] G, int first, int last, int k)
{
if (first <= last)
{
int pivot = partition(G, first, last);
if (pivot == k)
{
return G[k];
}
if (pivot < k)
{
return quickselect(G, first, pivot - 1, k);
}
return quickselect(G, pivot + 1, last, k);
}
return 0;
}
private int partition(int[] G, int first, int last)
{
int pivot = (first + last) / 2;
swap(G, last, pivot);
for (int i = first; i < last; i++)
{
if (G[i] < G[last])
{
swap(G, i, first);
first++;
}
}
swap(G, first, last);
return first;
}
private void swap(int[] G, int x, int y)
{
int tmp = G[x];
G[x] = G[y];
G[y] = tmp;
}