Question

我使用TList / TObjectList和TStringList（带有关联对象）来执行大量任务，无论是按原样还是作为更复杂结构的基础。虽然排序功能通常足够好，但我有时需要进行stable排序，两个列表都使用快速排序。

为TList和/或TStringList实现稳定排序的最简单方法是什么？我是否必须编写自己的排序例程，或者可以通过TStringListSortCompare / TListSortCompare使用一些聪明的技巧来完成它？

Answer 1

你必须编写自己的排序程序。

您可以阅读当前的QuickSort实现，并编写自己的稳定版本（例如合并排序或any other stable variant）。

一些技巧：

如果您确定索引是＆lt; Count，您可以使用快速指针数组（TList.List[]）而不是较慢的Items[]或GetItem()：子方法调用和范围检查会降低执行速度;
比较功能大部分时间都是搜索的速度瓶颈 - 所以要照顾这部分;
如果您需要速度，请使用真实的分析器而不是真实的（例如随机的）数据 - 但要在加快速度之前正确使用;
从现有的排序实施开始;
为了最小化堆栈空间，您可以使用临时记录在递归调用之间存储和共享变量。

Answer 2

这个问题相当陈旧，但这是我未来读者的答案：我最近也需要这个，并改编了书中的实现＆＃34; Delphi算法和数据结构的基础＆＃34;作者：Julian Bucknall。 TList，TObjectList和后代类的实现。它适用于Delphi 2009到XE7以及其他版本： http://alexandrecmachado.blogspot.com.br/2015/02/merge-sort-for-delphi.html

Answer 3

来自类似的问题How Can I Replace StringList.Sort with a Stable Sort in Delphi?，链接在这里由lkessler评论我需要复制到这里真正容易的技巧，如上所述。

只需将初始订单号添加到数据中，即可在CustomSort比较函数中对最后的比较条件进行排序和添加，以比较此初始订单号，从而轻松实现快速排序行为稳定。

简单，快速，聪明。在每个可排序项目上只花费一个额外的整数（或字节，或使用一些保留的存储，如TComponent.Tag，如果您对TComponents进行排序），并在它们上面进行一次初始化循环。

TObjectToSort = class
  ...
  Index: Integer;
end;

function MyStableSortComparer(List: TStringList; Index1, Index2: Integer): Integer;
var
  o1, o2: TObjectToSort; 
begin
  o1 := TObjectToSort(List.Objects[Index1]);
  o2 := TObjectToSort(List.Objects[Index2]);
  ...
  if Result = 0 then
    Result := o1.Index - o2.Index;
end;


for i := 0 to MyStrtingList.Count - 1 do
  TObjectToSort(MyStrtingList.Objects[i]).Index := i;
MyStrtingList.CustomSort(MyStableSortComparer);

Answer 4

对于任何使用泛型的人来说，这是一个随时可用的插入和合并排序实现，两种稳定的排序算法。

uses Generics.Defaults, Generics.Collections;

type
  TMySort = class
  public
    class procedure InsertionSort<T>(AArray: TArray<T>; FirstIndex, LastIndex: Integer; const AComparer: IComparer<T>); static;
    class procedure MergeSort<T>(AArray: TArray<T>; FirstIndex, LastIndex: Integer; const AComparer: IComparer<T>); static;
  end;

implementation

class procedure TMySort.InsertionSort<T>(AArray: TArray<T>; FirstIndex, LastIndex: Integer; const AComparer: IComparer<T>);
var
  UnsortedIdx, CompareIdx: Integer;
  AItem: T;
begin
  for UnsortedIdx := Succ(FirstIndex) to LastIndex do begin
    AItem := AArray[UnsortedIdx];
    CompareIdx := UnsortedIdx - 1;
    while (CompareIdx >= FirstIndex) and (AComparer.Compare(AItem, AArray[CompareIdx]) < 0) do begin
      AArray[CompareIdx + 1] := AArray[CompareIdx]; { shift the compared (bigger) item to the right }
      Dec(CompareIdx);
    end;
    AArray[CompareIdx + 1] := AItem;
  end;
end;

class procedure TMySort.MergeSort<T>(AArray: TArray<T>; FirstIndex, LastIndex: Integer; const AComparer: IComparer<T>);
const
  MinMergeSortLimit = 16;
var
  LeftLast, RightFirst: Integer;
  LeftIdx, RightIdx, SortedIdx: Integer;
  LeftCount: Integer;
  TmpLeftArray: TArray<T>;
begin
  if (LastIndex - FirstIndex) < MinMergeSortLimit then
    { sort small chunks with insertion sort (recursion ends here)}
    TMySort.InsertionSort<T>(AArray, FirstIndex, LastIndex, AComparer)
  else begin
    { MERGE SORT }
    { calculate the index for splitting the array in left and right halves }
    LeftLast := (FirstIndex + LastIndex) div 2;
    RightFirst := LeftLast + 1;
    { sort both halves of the array recursively }
    TMySort.MergeSort<T>(AArray, FirstIndex, LeftLast, AComparer);
    TMySort.MergeSort<T>(AArray, RightFirst, LastIndex, AComparer);
    { copy the first half of the array to a temporary array }
    LeftCount := LeftLast - FirstIndex + 1;
    TmpLeftArray := System.Copy(AArray, FirstIndex, LeftCount);
    { setup the loop variables }
    LeftIdx := 0;  { left array to merge -> moved to TmpLeftArray, starts at index 0 }
    RightIdx := RightFirst; { right array to merge -> second half of AArray }
    SortedIdx := FirstIndex - 1; { range of merged items }
    { merge item by item until one of the arrays is empty }
    while (LeftIdx < LeftCount) and (RightIdx <= LastIndex) do begin
      { get the smaller item from the next items in both arrays and move it
        each step will increase the sorted range by 1 and decrease the items still to merge by 1}
      Inc(SortedIdx);
      if AComparer.Compare(TmpLeftArray[LeftIdx], AArray[RightIdx]) <= 0 then begin
        AArray[SortedIdx] := TmpLeftArray[LeftIdx];
        Inc(LeftIdx);
      end else begin
        AArray[SortedIdx] := AArray[RightIdx];
        Inc(RightIdx);
      end;
    end;
    { copy the rest of the left array, if there is any}
    while (LeftIdx < LeftCount) do begin
      Inc(SortedIdx);
      AArray[SortedIdx] := TmpLeftArray[LeftIdx];
      Inc(LeftIdx);
    end;
    { any rest of the right array is already in place }
  end;
end;

实现是针对数组的，也适用于TList / TObjectList（因为它们的Items属性是一个数组）。

var
  AList: TList<T>;
  AComparer: IComparer<T>;
begin
  ...
  TMySort.MergeSort<T>(AList.List, 0, AList.Count-1, AComparer);
  ...
end;

除了稳定之外，根据我的经验，这种合并排序实现确实表现出比内置快速排序更好的性能（尽管它使用更多内存）。

为TList和TStringList添加稳定排序的简便方法

4 个答案: