Maxmin algorithm implementation
Some comments:

Firstly the interface is odd.  Normally when you pass an array, you pass it's
size and a pointer to the first element.  In the context of your function this
means:

int* maxmin(const int list[], size_t size, int max, int min);


Then you call this with:

maxmin(list, mid, max, min);
maxmin(list + mid, size - mid, max1, min1);


or from main

values = maxmin(list, size, list[0], list[0]);


This saves a call parameter (fewer is always preferable) and makes the
function more 'normal'.



Beyond that, what stand out are the return of a static array and the use of
globals.  Maybe thread safety is not on your mind and this can be ignored, but
bear in mind that returning a static is rarely done.  And globals are often best avoided, if they can be.



The other thing that strikes me is the awkwardness of the code.  Arguably a
matter of opinion, there are many variables and their names are hard to tell
apart.  More importantly the need to find both max and min values complicates
the function enormously.

Consider the same task but only looking for the minimum value:

int min(const int list[], const size_t size)
{
    if (size == 1) {
        return list[0];
    }
    else if (size == 2) {
        return list[0] &lt; list[1] ? list[0] : list[1];
    }
    size_t half = size / 2;
    int n = min(list, half);
    int m = min(list + half, size - half);
    return n &lt; m ? n : m;
}


This is so much simpler!  And the max version just involves reversing the
two comparisons.  I would be looking for an excuse to use these rather than
your combined function.  Against my functions is the fact that calling max
and min will be slower than just calling yours (but less than 2:1).  In
their favour, you might not always want both values. 

As this is just an exercise, you don't have to care.  But in practice I
believe strongly that it is always worth simplifying the
requirement/specification if it results in simpler code.