``````{
>I'm in need of a FAST way of finding the largest and the smallest
>30 numbers out of about 1000 different numbers.
> ...Assuming that the 1000 numbers are in random-order, I imagine
> that the simplest (perhaps fastest too) method would be to:
>    1- Read the numbers in an Array.
>    2- QuickSort the Array.
>    3- First 30 and last 30 of Array are the numbers you want.
>  ...Here's a QuickSort demo Program that should help you With the
>  sort: ...

Stop the presses, stop the presses!

Remember the recent Integer sort contest, on the Intelec Programming
conference?  The fastest method was a "counting" sort technique, which
used the Integers (to be sorted) as indexes of an Array.

You asked John Kuhn how it worked, as his example code was in messy
C.  I sent you an explanation, along With example TP source.  Around
that time my link to Intelec was intermittently broken; I didn't
hear back from you - so you may not have received my message (dated
Jan.02.1993).  I hope you won't mind if I re-post it here and now...

In a message With John Kuhn...
> Simply toggle the sign bit of the values beFore sorting. Everything
> falls into place appropriately from there.
>  ...OK, but how about toggling them back to their original
>  state AFTER sorting? (I want to maintain negative numbers)
>  How can you tell which data elements are negative numbers???

Hi Guy,

if you've got all of this under your belt, then please disregard
the following explanation ...

By toggling the high bit, the Integers are changed in a way that,
conveniently, allows sorting by magnitude: from the "most negative"
to "most positive," left to right, using an Array With unsigned
indexes numbering 0...FFFFh.  The Array size represents the number
of all possible (16-bit) Integers... -32768 to 32767.

The "Count Sort" involves taking an Integer, toggling its high bit
(whether the Integer is originally positive or negative), then
using this tweaked value as an index into the Array.  The tweaked
value is used only as an Array index (it becomes an unsigned
index somewhere within 0..FFFFh, inclusive).

The Array elements, which are initialized to zero, are simply the
counts of the _occurrences_ of each Integer.  The original Integers,
With proper sign, are _derived_ from the indexes which point to
non-zero elements (after the "sort")... ie. an original Integer is
derived by toggling the high bit of a non-zero element's index.

Array elements of zero indicate that no Integer of the corresponding
(derived) value was encountered, and can be ignored.  if any element
is non-zero, its index is used to derive the original Integer.  if
an Array element is greater than one (1), then the corresponding
Integer occurred more than once.

A picture is worth 1000 Words:  The following simplified example
sorts some negative Integers.  The entire Count Sort is done by
a Single For-do-inC() loop - hence its speed.  The xors do the
required high-bit toggling ...
}

Program DemoCountSort; { Turbo Pascal Count Sort.  G.Vigneault }

{ some negative Integers to sort ... }
Const
SomeNegs        : Array [0..20] of Integer =
(-2,-18,-18,-20000,-100,-10,-8,-11,-5,
-1300,-17,-1,-16000,-4,-12,-15,-19,-1,
-31234,-6,-7000 );

{ pick an Array to acComplish Count Sort ... }
Var
NegNumArray     : Array [\$0000..\$7FFF] of Byte;
{ PosNumArray     : Array [\$8000..\$FFFF] of Byte;            }
{ AllNumArray     : Array [\$0000..\$FFFF] of Byte;  use heap  }
Index           : Word;
IntCount        : Byte;

begin
{ Initialize }
FillChar( NegNumArray, Sizeof(NegNumArray), 0 );

{ Count Sort (the inC does this) ... }

For Index := 0 to 20 do
{ Just 21 negative Integers to sort }
inC( NegNumArray[ Word(SomeNegs[Index] xor \$8000) ]);

{ then display the sorted Integers ... }
For Index := 0 to \$7FFF do
{ Check each Array element }
For IntCount:= 1 to NegNumArray[Index] do
{ For multiples }
WriteLn( Integer(Index xor \$8000) ); { derive value }

end { DemoCountSort }.

``````