Question

Given 2 arrays with int, A1 and A2. A1 length is L1, A2 length is L1+L2.
The first L2 elements of A1 and A2 have been sorted. Combine the first L2 elements into A2.
e.g.

   A1:  1  3  6  0
   A2:  2  5  7  13  10 22 11 
   result: 
   A1 + A2:  1 2 3 5 6 7 13 10 22  11

my solutions:

Pick each element by putting min { A1[i], A2[i]} into a array B[i], O(2 * L2)
Copy B to A2. O(L1 + L2).

Unsorted part should not be changed.

Any better solutions ?

thanks

Answer 1

int* semiMerge(int*, int, int*, int);

int main() {
  const int A1[] = {1, 3, 6, 0};
  const int A2[] = {2, 5, 7, 13, 10, 22, 11};

  const int L1 = sizeof(A1)/sizeof(int);
  const int L2 = sizeof(A2)/sizeof(int) - L1;

  int* out = semiMerge(A1, L1, A2, L2);
}

int* semiMerge(A1, L1, A2, L2) {
  int* output = new int[L2 + L2 + L1];

  //merge does a sorted combination of the items--both sets must be sorted up to the endpoints;
  //we want to merge only the first L1 results from each array
  std::merge(A1, A1 + L2,
             A2, A2 + L2,
             output);
  //at this point, we have an array of 2*L1 elements, all sorted properly.


  //we want to start looking at the first element we didn't copy from A2,
  //the -1 is to account for the fact that begin() + L1 is the start of the L1+1th slot
  std::copy(A2 + L2,
            A2 + L2 + L1, 
            (output + L2 + L2 - 1));

return output;
}

I chose to show A1 and A1 as static arrays, but if you’re getting them as int*s to heap-allocated arrays, and if it’s important that the finished array be placed in L2, you can then say delete[] L2; L2 = out; after the call to semiMerge(). I chose not to do this in main because I represented A2 as a static array, while switching it out for the contents of out would require it to be a pointer to a dynamic array.