I
don't really care, do what you like, it was just another option, but I
have to say:
1)
Copying the code for a bubble sort on an array is not "re-inventing the
wheel", it is cut-paste implementing a time-honoured and simple sorting
algorithm that everyone does in first year university. So most people
will quickly grasp what is happening, not that they wouldn't any other way
either. All you had to do was cut-paste, then change a couple of little bits
of the algorithm.
2)
Bubble sort, quick sort, shell sort, they all sort. Quick sort faster, bubble
sort uses less memory and is simpler to understand. At the end of the day
modern computers have so much speed and memory who cares?
3)
Bubble sort for an array is appropriate when you want to sort an
array.
Of
course, you could use a stringlist, and do a dodgy typecast of a TObject
pointer to an integer which you use to index the array. But we want to
gain a sorted array, not a sorted reference list.
Or
you could first copy each item of the array into some sort of object or
structure which you then add to a list, sort the list, then copy each
individually item back into another array. And then tell me it's quicker. Hey,
maybe it is, but you'd have to test that, not tell me off the top of your
head.
But
yeah, do what works for you, I was just providing another
option.
-----Original Message-----
From:
[EMAIL PROTECTED] [mailto:[EMAIL PROTECTED] On
Behalf Of Leigh Wanstead
Sent: Thursday, May 27 2004 4:28
p.m.
To: NZ Borland Developers Group - Delphi
List
Subject: RE: [DUG] dynamic array items
I
have not followed the discussion closely.
I
just read bubble sort topic and thought why reinvent the
whole wheel.
TList already has a method Sort which use QuickSort. QuickSort is
better than bubble sort.
All you need to do is just offer a method TListSortCompare to compare
the item in the list.
Delphi version 7
Regards
Leigh
[Leigh
Wanstead] -----Original
Message-----
From: [EMAIL PROTECTED]
[mailto:[EMAIL PROTECTED]On Behalf Of Allan,
Samuel
Sent: Thursday, May 27, 2004 1:51 PM
To: NZ
Borland Developers Group - Delphi List
Subject: RE: [DUG] dynamic
array items
This is also good, but will require a little modification. I pulled
it off some website, most of the code is actually setup and reporting on
how the sort is going. It has the advantage of being stock first year
stuff. I put colour around the sort code.
The Bubble Sort
The concept behind the bubble sort is
simple. Instead of trying to compare one record to the entire rest
of the list, why not just compare it to it's neighbor? If every
record is equal to or less than the next one, the entire list is
sorted. The logic of the bubble sort is this:
- Start Scan
- Compare each record to the next one
- Swap any that are out of order.
- Continue scanning until no more swaps are required.
The
whole thing can be written in 30 lines of code.
procedure TForm1.SortNumbers(Sender:TObject);
const
ArySize=20
var
ary:array[1..ArySize] of extended;
e:extended;
t:byte;
NoExchanges:boolean;
begin
//fill the array
randomize;
For t:=1 to ArySize do ary[t]:=random*100;
Memo1.Lines.Clear;
For t:=1 to ArySize do Memo1.Lines.Add(Format('%8.4f',[ary[t]]));
//tell the user we are sorting
Memo2.Lines.Clear;
Memo2.Lines.Add('Sorting...');
refresh; //force a repaint
---------- Start of Sort -----------------------------------------
//sort really begins here
Repeat
NoExchanges:=true;
For t:=1 to ArySize-1 do
begin
if Ary[t] > Ary[t+1] then
begin //we have to switch.
NoExchanges:=False; //We have to tell the sort we aren't done.
e := Ary[t]; //store one of the numbers in a temporary location.
Ary[t] := Ary[t+1]; //put the other in its place.
Ary[t+1] := e; //Put the copy of the first number in the second slot.
end;
end;
//if there has been even one switch, NoExchanges is false;
Until NoExchanges;
--------------------------------- End of Sort --------------------------------------------------------------------------
//output the results
Memo2.Lines.Clear;
For t:=1 to ArySize do Memo2.Lines.Add(Format('%8.4f',[ary[t]]));
end;
I've thought of that but the writing to
text file can occur multiple times and I would rather not fiddle
with that part of the program. I really just want to get the items
in the Files array in the correct order the quicket possible
way.
For those interested, this seems to work
very well. Files is a global array of FileRec. TempFiles is
a local array of FileRec.
for FileCnt :=
0 to High(Files) do
FileList.AddObject(ExtractFilename(Files[FileCnt].Filename),TObject(FileCnt));
FileList.Sort;
SetLength(TempFiles,Length(Files));
for
FileCnt := 0 to High(TempFiles) do
TempFiles[FileCnt] :=
Files[Integer(FileList.Objects[FileCnt])];
CopyMemory(Files,TempFiles,Sizeof(FileRec)*FileCnt);
Cheers,
Ross.
----- Original Message -----
Sent: Thursday, May 27, 2004
10:48 AM
Subject: Re: [DUG] dynamic array
items
What about a TList - the TList containing
pointers to the already-allocated records and you just resort the
pointers and then write to file the records contained at the pointer
location using the TList order.
Regards
Paul McKenzie
Analyst Programmer
SMSS
Ltd.
