Best way to sort an array

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  begin    Result := TComparer<Integer>.Default.Compare(Left.SortOrder, Right.SortOrder);  end));

(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;end;

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;  end;

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    tsExamples.AddObject(MyDA[i].SomethingElse,TObject(MyDA[i].SortOrder));  end;

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;begin  Result := integer(ts.Objects[i]) - integer(ts.Objects[j];end;

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 belowfunction CompareRecords(Item1, Item2: Integer): Integer;var i,j: integer;begin  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);end;

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;  end;

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.

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.