DN> KK>   for(outer = 0; outer < end; outer++)
DN> KK>   {
DN> KK>     swap = outer;
DN> KK>     for(inner = outer; inner < elements; inner++)
DN> KK>       if((array[swap] > array[inner] && !reverse)
DN> KK>         || (array[swap] < array[inner] && reverse))
DN> Yick! Choosing your sort direction for each and every iteration!!
DN> If you must do this, why not use the following?
DN>     if (reverse ? array[swap] < array[inner]
DN>        : array[swap] > array[inner])
DN>   It is still dog slow, but it should produce better code
DN>   than what you already have.
DN>   [Especially using Borland's wonderful optimizer.]
   Right. In a working implementation, I would have two loops,
   one for forward sort, and one for reverse.
void selectionsort(int *array, int elements)
{
   int outer, inner, swap, tmp, end, reverse;
   reverse = (elements < 0) ? 1 : 0;
   elements = reverse ? -elements : elements;
   end = elements - 1;
   if(reverse)
   {
      for(outer = 0; outer < end; outer++)
      {
         swap = outer;
         for(inner = outer; inner < elements; inner++)
           if(array[swap] < array[inner])
                swap = inner;
         if(swap > outer)
         {
            tmp = array[outer];
            array[outer] = array[swap];
            array[swap] = tmp;
         }
   }
   else
   {
      for(outer = 0; outer < end; outer++)
      {
         swap = outer;
         for(inner = outer; inner < elements; inner++)
           if(array[swap] > array[inner])
                swap = inner;
         if(swap > outer)
         {
            tmp = array[outer];
            array[outer] = array[swap];
            array[swap] = tmp;
         }
      }
   }
}
> ] Give me only the facts. I grow weary of all these Truths....
---
---------------