Funny Programming in Delphi - Methods of SortingIntroduction
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
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:
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;
Try the fastest sorting method and let us know
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 AuthorIng. Jana Pšenčíková