quicksort (n arrays should be treated as 1 and values remapped as needed)

Question

I have a linked list of arrays (struct at bottom of post)

Each array may have values like the below example

Array1[] = {6,36,8,23};
Array2[] = {8,23,5,73};
Array3[] = {2,5,1,9};

I need to sort these so that all 3 arrays are treated as 1 large array...

I need to use quicksort so that it uses in-place processing... I am working with very large arrays and cannot afford to use additional memory..

The result should be something like this

Array1[] = {1,2,5,5};
Array2[] = {6,8,8,9};
Array3[] = {23,23,36,73};

Currently i am only able to sort each array individually... but thats not exactly what i need :(

struct iSection {
    unsigned long     Section_Count; // Total # of points in this block of memory

    int              *Section_Arr;   // Point cloud for current block of memory
    struct iSection  *Next;          // Pointer to next section
} iSection;


struct iDatabase {
    struct iSection     *First_Section;
    struct iSection     *Last_Section;
} iDatabase;

Answer 1

It's not that hard, more an interfacing issue then an algorithmics issue.

Write a wrapper container that provides an interface for accessing members and writing (say operator[] in C++) and internally it maps the size_t index argument to the right array. This wrapper class does need the size of every array though to be able to correctly map the index.

An example pseudocode operator[] would be:

int& JointDatabase::operator[](size_t index) {
    // database is an iDatabase
    iSection *cur = database.First_Section;

    while (cur != database.Last_Section && index >= cur->Section_Count) {
        index -= cur->Section_Count;
        cur = cur->Next;
    }

    return cur->Section_Arr[index];
}

Then use this wrapper class as you would use a normal container in your Quicksort algorith.