Question

Order Statistics:

A. Given two sorted arrays X and Y of equal size n, use Quick-Select to find the median of all 2n elements in arrays X and Y. Can you improve Quick-Select by choosing better pivots at every step?(in java)

B. Show some experiments of your improved Quick-Select with arrays of size n=50. You can assume, if you want, that all the elements in the two arrays are distinct.

Answer 1

A:-here two arrays are x and y of the same size n

#include<bits/stdc++.h>

using namespace std;

int median(int [], int); /* to get median of a sorted array */

/* This function returns median of x[] and y[].

   Assumptions in this function:

   Both x[] and y[] are sorted arrays

   Both have n elements */

int getMedian(int x[], int y[], int n)

{

    /* return -1 for invalid input */

    if (n <= 0)

        return -1;

    if (n == 1)

        return (x[0] + y[0])/2;

    if (n == 2)

        return (max(x[0], y[0]) + min(ar1[1], y[1])) / 2;

    int m1 = median(x n); /* get the median of the first array */

    int m2 = median(y, n); /* get the median of the second array */

/* If medians are equal then return either m1 or m2 */

    if (m1 == m2)

        return m1;

    /* if m1 < m2 then median must exist in ar1[m1....] and

y[....m2] */

    if (m1 < m2)

    {

        if (n % 2 == 0)

            return getMedian(x + n/2 - 1, y, n - n/2 +1);

        return getMedian(x + n/2, y, n - n/2);

    }

/* if m1 > m2 then median must exist in x[....m1] and

y[m2...] */

    if (n % 2 == 0)

        return getMedian(y + n/2 - 1, x, n - n/2 + 1);

    return getMedian(y + n/2, x, n - n/2);

}

/* Function to get median of a sorted array */

int median(int arr[], int n)

{

    if (n%2 == 0)

        return (arr[n/2] + arr[n/2-1])/2;

    else

        return arr[n/2];

}

/* Driver program to test above function */

int main()

{

    int x[] = {1, 2, 3, 6};

    int y[] = {4, 6, 8, 10};

    int n1 = sizeof(x)/sizeof(x[0]);

    int n2 = sizeof(y)/sizeof(y[0]);

    if (n1 == n2)

        printf("Median is %d", getMedian(x, y, n1));

    else

        printf("Doesn't work for arrays of unequal size");

    return 0;

}

The idea of the quick select is quite simple: just like with quicksort, select a random element from the list, and place every item that is smaller to the first half of the array, and every element that is equal to or greater than the pivot, in the second half (the ‘half’ is not entirely correct, as it is possible that the result will not be exactly ‘half’).

So a step would look like this:

Arr = [5 1 4 3 2]
Pivot = [4]

Steps:

swap [5] and [2] as 5>=4 and 2<
[2 1 4 3 5]

swap [4] and [3] as 4>=4 and 3<4
[2 1 3 4 5]

if we are looking for the first 3 elements, we can stop, we found them. If we are looking for the 3rd element, we need more iteration, but we know we must look for it in the first half of the array hence we can ignore the rest:

Arr = [2 1 3 …]
Pivot = [1]

Steps:
swap [2] and [1] as 2>=2 and 1<2
[1 2 3 …]

So it is quite clear that this algorithm runs in linear time using java

b:-

void swap(int* a, int* b)

{

    int t = *a;

    *a = *b;

    *b = t;

}

int partition (int arr[], int low, int high)

{

    int pivot = arr[high];    // pivot

    int i = (low - 1); // Index of smaller element

    for (int j = low; j <= high- 1; j++)

    {

        // If current element is smaller than or

        // equal to pivot

        if (arr[j] <= pivot)

        {

            i++;    // increment index of smaller element

            swap(&arr[i], &arr[j]);

        }

    }

    swap(&arr[i + 1], &arr[high]);

    return (i + 1);

}

/* The main function that implements QuickSort

arr[] --> Array to be sorted,

  low --> Starting index,

  high --> Ending index */

void quickSort(int arr[], int low, int high)

{

    if (low < high)

    {

        /* pi is partitioning index, arr[p] is now

           at right place */

        int pi = partition(arr, low, high);

        // Separately sort elements before

        // partition and after partition

        quickSort(arr, low, pi - 1);

        quickSort(arr, pi + 1, high);

    }

}

/* Function to print an array */

void printArray(int arr[], int size)

{

    int i;

    for (i=0; i < size; i++)

        printf("%d ", arr[i]);

    printf("\n");

}

int main()

{

    int arr[] = {10, 7, 8, 9, 1, 5,......n};

    int n = sizeof(arr)/sizeof(arr[0]);

    quickSort(arr, 0, n-1);

    printf("Sorted array: \n");

    printArray(arr, n);

    return 0;

}