Give you two sorted array, find the k-th smallest elements of union of A and B, you can assume that there are no duplicate elements. the size of A is m, and size of B is n, both them are in acsending order.
    At first, we can use brute-force,  malloc a new array of size m+n, and merge A and B into this new array, then we can get the k-th smallest element, or k-th smallest elements. time complexity is O（m+n）， and the space complexity is O（m+n）；
    A better way, using two pointers: i, and j, i proints head of A, j points to head of B, at the same time make a new malloc of array of size k. then we compare A[i] and B[j], we get the minimum of them and increase pointer of the minimum one in order to get next index of the array its belonged to. time complexity is O（k）， and space complexity is O（k）。 here is the codes:
    [cpp]
    #include<iostream>
    #include<cassert>
    using namespace std;
    int *get_k_th_minimum（int *a, int len_a, int *b, int len_b, int k） {
    int p = 0;
    int i = 0;
    int j = 0;
    int *c = （int*）malloc（sizeof（int） * k）；
    if（a == NULL || b == NULL || k > （len_a + len_b）） {
    return NULL;
    }
    while（p < k && i < len_a && j < len_b） {
    if（a[i] < b[j]） {
    c[p++] = a[i];
    i++;
    } else {
    c[p++] = b[j];
    j++;
    }
    }
    return c;
    }
    void main（） {
    int a[] = {1, 3, 5, 7, 9};
    int b[] = {2, 4, 6, 8, 10};
    int len_a = sizeof（a） / sizeof（int）；
    int len_b = sizeof（b） / sizeof（int）；
    int k = 5;
    int *p = get_k_th_minimum（a, len_a, b, len_b, k）；
    int i = 0;
    if（p） {
    for（i = 0; i < k; i++） {
    cout 《 p[i] 《 " ";
    }
    cout 《 endl;
    }
    getchar（）；
    }
    Then a more better way, it takes O（lgm + lgn） time to get the k-th minimum elements, not all the number of k elements. then we will take O（k） time to get these elements from A and B. And space complexity is O（1）。