Say I have an array of records which I want to sort based on one of the fields in the record. What's the best way to achieve this?

TExample = record
  SortOrder : integer;
  SomethingElse : string;

var SomeVar : array of TExample;
+1  A: 

Use one of the sort alorithms propose by Wikipedia. The Swap function should swap array elements using a temporary variable of the same type as the array elements. Use a stable sort if you want entries with the same SortOrder integer value to stay in the order they were in the first place.

Ralph Rickenbach
+14  A: 

You can add pointers to the elements of the array to a TList, then call TList.Sort with a comparison function, and finally create a new array and copy the values out of the TList in the desired order.

However, if you're using the next version, D2009, there is a new collections library which can sort arrays. It takes an optional IComparer<TExample> implementation for custom sorting orders. Here it is in action for your specific case:

TArray.Sort<TExample>(SomeVar , TDelegatedComparer<TExample>.Construct(
  function(const Left, Right: TExample): Integer
    Result := TComparer<Integer>.Default.Compare(Left.SortOrder, Right.SortOrder);
Barry Kelly
+2  A: 

With an array, I'd use either quicksort or possibly heapsort, and just change the comparison to use TExample.SortOrder, the swap part is still going to just act on the array and swap pointers. If the array is very large then you may want a linked list structure if there's a lot of insertion and deletion.

C based routines, there are several here

Another site, but has pascal source

+3  A: 

if your need sorted by string then use sorted TStringList and add record by TString.AddObject(string, Pointer(int_val)).

But If need sort by integer field and string - use TObjectList and after adding all records call TObjectList.Sort with necessary sorted functions as parameter.

+1  A: 

TStringList have efficient Sort Method.
If you want Sort use a TStringList object with Sorted property to True.

NOTE: For more speed, add objects in a not Sorted TStringList and at the end change the property to True.
NOTE: For sort by nteger Field, convert to String.
NOTE: If there are duplicate values, this method not is Valid.


+1  A: 

This all depends on the number of records you are sorting. If you are only sorting less than a few hundred then the other sort methods work fine, if you are going to be sorting more, then take a good look at the old trusty Turbo Power SysTools project. There is a very good sort algorithm included in the source. One that does a very good job sorting millions of records in a efficient manner.

If you are going to use the tStringList method of sorting a list of records, make sure that your integer is padded to the right before inserting it into the list. You can use the format('%.10d',[rec.sortorder]) to right align to 10 digits for example.

+5  A: 

(I know this is a year later, but still useful stuff.)

Skamradt's suggestion to pad integer values assumes you are going to sort using a string compare. This would be slow. Calling format() for each insert, slower still. Instead, you want to do an integer compare.

You start with a record type:

TExample = record
  SortOrder : integer;
  SomethingElse : string;

You didn't state how the records were stored, or how you wanted to access them once sorted. So let's assume you put them in a Dynamic Array:

var MyDA  Array of TExample; 
  SetLength(MyDA,NewSize);           //allocate memory for the dynamic array
  for i:=0 to NewSize-1 do begin        //fill the array with records
    MyDA[i].SortOrder := SomeInteger;
    MyDA[i].SomethingElse := SomeString;

Now you want to sort this array by the integer value SortOrder. If what you want out is a TStringList (so you can use the ts.Find method) then you should add each string to the list and add the SortOrder as a pointer. Then sort on the pointer:

var  tsExamples: TStringList;         //declare it somewhere (global or local)
  tsExamples := tStringList.create;   //allocate it somewhere (and free it later!)
  tsExamples.Clear;                   //now let's use it
  tsExamples.sorted := False;         //don't want to sort after every add
  tsExamples.Capacity := High(MyDA)+1 //don't want to increase size with every add
                                      //an empty dynamic array has High() = -1
  for i:=0 to High(MyDA) do begin

Note the trick of casting the Integer SortOrder into a TObject pointer, which is stored in the TStringList.Object property. (This depends upon the fact that Integer and Pointer are the same size.) Somewhere we must define a function to compare the TObject pointers:

function CompareObjects(ts:tStringList; Item1,Item2: integer): Integer;
var i,j: integer;
  Result := integer(ts.Objects[i]) - integer(ts.Objects[j];

Now, we can sort the tsList on .Object by calling .CustomSort instead of .Sort (which would sort on the string value.)

tsExample.CustomSort(@CompareObjects);     //Sort the list

The TStringList is now sorted, so you can iterate over it from 0 to .Count-1 and read the strings in sorted order.

But suppose you didn't want a TStringList, just an array in sorted order. Or the records contain more data than just the one string in this example, and your sort order is more complex. You can skip the step of adding every string, and just add the array index as Items in a TList. Do everything above the same way, except use a TList instead of TStringList:

var Mlist: TList;                 //a list of Pointers
  for i:=0 to High(MyDA) do
    Mlist.add(Pointer(i));        //cast the array index as a Pointer
  Mlist.Sort(@CompareRecords);    //using the compare function below

function CompareRecords(Item1, Item2: Integer): Integer;
var i,j: integer;
  i := integer(item1);            //recover the index into MyDA
  j := integer(item2);            // and use it to access any field
  Result := SomeFunctionOf(MyDA[i].SomeField) - SomeFunctionOf(MyDA[j].SomeField);

Now that Mlist is sorted, use it as a lookup table to access the array in sorted order:

  for i:=0 to Mlist.Count-1 do begin
    Something := MyDA[integer(Mlist[i])].SomeField;

As i iterates over the TList, we get back the array indexes in sorted order. We just need to cast them back to integers, since the TList thinks they're pointers.

I like doing it this way, but you could also put real pointers to array elements in the TList by adding the Address of the array element instead of it's index. Then to use them you would cast them as pointers to TExample records. This is what Barry Kelly and CoolMagic said to do in their answers.

Guy Gordon
looks like it's just one day later :)
Wouter van Nifterick