Funny Programming in Delphi - Methods of Sorting

Having very advanced means and methods for sorting unlimited amount of values, we don't think about principles of creating ordered sets and sequences. We rely on property Sorted or use full power of SQL keyword ORDER BY and aren't interested how to customize unsorted sets of number. But immersing into elementary principles of sorting can be extremely useful and funny. Let's have a look!

Methods of sorting values

We will discuss four different methods for sorting, however each of them works in a different way and it's variable regarding time demands.

• Select sort
• Bubble sort (simplified)
• Select sort (classic)
• Shake sort

Used variables

Given example assumes entering random figure of integer values into a Memo component. As soon as desired values are written, you can choose among four methods of sorting. Finally, click Go button and you'll see sorted sequence of your numbers in the second Memo component, together with time needed for main sorting procedure. According to your CPU unit speed, common count of values will consume almost no time, maybe 0.001 sec.

Let's skim over all used sorting methods:

Select sort

for I:=1 to N-1 do    //Outer loop - if minimum is found in inner loop, unsorted sequence is shortened by 1
  begin
   for J:=I+1 to N  do   //Inner loop - conducts one pass through the queue
   begin
    if A[J] < A[I]     //Each element in unsorted sequence is compared with the first one
    then begin
     POM:= A[I];
     A[I]:= A[J];
     A[J]:= POM;
    end;
   end;
  end;

Bubble sort (simplified)

for I:=N downto 2 do   //Outer loop - control variable is decreasing
  begin
   for J:=1 to I-1  do   //Inner loop - conducts one pass through the queue
   begin
    if A[J] > A[J+1]
    then
    begin
     POM:= A[J];
     A[J]:= A[J+1];
     A[J+1]:= POM;
    end;
   end;
  end;

Bubble sort (classic)

for I:=N downto 2 do    //Outer loop - control variable is decreasing
  begin
   ZM:=0;
   for J:=1 to I-1  do   //Inner loop / conducts one pass through the queue
   begin
    if A[J] > A[J+1]
    then
    begin
     POM:= A[J];
     A[J]:= A[J+1];
     A[J+1]:= POM;
     ZM:=1;       //Change is encountered
    end;
   end;
   if ZM=0 then break;  //If no change, breaks the loop
   ZM:=0;               //Elements order has changed, must be passed again
  end;

Shake sort

D:=1;                               //Lower limit is at the beginning of the queue
  H:=N-1;      //Upper limit must allow a comparison with an element one position higher
  PZM:=1;
  repeat       //Outer loop with a condition at the end
   for J:= D to H do                //Loop 1 - from bottom to top
   begin
    if A[J] > A[J+1]
    then
    begin
     POM:= A[J]; A[J]:= A[J+1]; A[J+1]:= POM;
     PZM:=J            //Last change is saved
    end;
   end;
   H:=PZM-1;  //Shifts upper limit from which searching is started
   for J:= H downto D do            //Loop 2 - from top to bottom
   begin
    if A[J+1] < A[J]
    then
    begin
     POM:= A[J]; A[J]:= A[J+1]; A[J+1]:= POM;
     PZM:=J            //Last change
    end;
   end;
   D:=PZM+1;  //Shifts lower limit from which searching is started
  until D>H;   //Are limits equal? End of outer loop

If you like, you can fill first Memo component with large amount of values, for instance 10 000, and try which sorting method provides the fastest results. We'd be grateful if you give us a feedback about your experience.

Sample project regarding this topic can be downloaded from here.

About the Author