Performance of Median routine using min performs abysmally
The structure of your function is

for (i = 0; i &lt; halflength; ++i)    // N/2 iterations
{
    ...

    for (j = 0; j &lt; length; ++j)    // N iterations
    {
        ... 
    }

    for (k = 0; k &lt; length; ++k)    // N iterations
    {
        ...
    }
}


this makes \$ N/2 (N+N) = N^2\$ iterations, where \$ N \$ is the length
of the array.

There are small improvements possible: In the k-loop, if a
matching element has been found, you can break-out early:

    // now that we know which is the smallest number, eliminate only 1st occurance of it            
    for (k = 0; k &lt; length; ++k)
    {
        float comparitor = array[k];                
        if (comparitor == lowestInArray)
        {
            array[k] = highNumber;
            break;
        }
    }


But actually this loop is not needed at all: In the j-loop,
remember the index where the lowest element has been found,
and then set to a "large" number directly:

    float lowestInArray = array[0];
    unsigned int indexOfLowest = 0;

    for (unsigned int j = 1; j &lt; length; ++j) {
        float comparitor = array[j];
        if (comparitor &lt; lowestInArray) {
            lowestInArray = comparitor;
            indexOfLowest = j;
        }
    }
    array[indexOfLowest] = FLT_MAX;


Also FLT_MAX is a better choice than 999.0 for a "large number".
This reduces the number of iterations by a factor of 2.


  If it finds the same number a second time, it ignores the number until
  the next iteration.


Yes, but the j-loop still traverses over the entire array. Instead of
replacing the found minimal element by FLT_MAX, you could replace it
by the last array element, and then reduce the upper bound
for the j-loop accordingly:

for (unsigned int i = 0; i &lt; halflength; ++i)
{
    float lowestInArray = array[0];
    unsigned int indexOfLowest = 0;

    for (unsigned int j = 0; j &lt; length - i; ++j) {
        float comparitor = array[j];
        if (comparitor &lt; lowestInArray) {
            indexOfLowest = comparitor;
            indexOfLowest = j;
        }
    }
    array[indexOfLowest] = array[length - i - 1];
    median = lowestInArray;
}


This reduces the number of iterations again. But it is still
\$  O(N^2) \$, and I doubt that much more is possible with this
algorithm.

As you already noticed, sorting the array first and then taking
the middle element is faster. This is no surprise since sorting can
typically be done in \$  O(N \log N) \$ operations.