Улучшение техники сортировки в убывающем порядке в Delphi XE8

Delphi , Базы данных , Сортировка и Фильтр

В статье мы рассмотрим вопрос сортировки элементов в списке в убывающем порядке в Delphi XE8. Мы обсудим существующий подход и предложим улучшенный вариант с использованием встроенного алгоритма сортировки и хранения данных в структуре данных, которая остается упорядоченной.

Существующий подход

Автор вопроса предложил технику, при которой данные из списка добавляются в экземпляр TStringList, который затем сортируется в порядке возрастания. Отсортированные элементы извлекаются в обратном порядке и добавляются в список, что дает эффект сортировки в убывающем порядке.

Вот пример кода, демонстрирующий этот подход:

procedure TBCSLBDemoC.DescendLZB(var lb: TListBox);
var
  sc: TStringList;
  i: Integer;
  rdt: TDateTime;
  buf : string;
begin
  sc := TStringList.Create;
  i := 0;
  repeat
    rdt := TFile.GetLastAccessTime(lb.Items[i]);
    sc.Add(FormatDateTime('YYYYMMDDHHMMSS', rdt) + ' ' + lb.Items[i]);
    Inc(i);
  until (i > (lb.Count - 1));
  sc.Sort;
  lb.Sorted := false;
  lb.Items.Clear;
  i := sc.Count - 1;
  repeat
    buf := sc[i];
    Delete(buf, 1, 15);
    lb.Items.Add(buf);
    dec(i);
  until (i < 0);
  sc.Free;
end;

Хотя этот подход работает, он создает новый экземпляр TStringList для каждой сортировки, что может привести к неэффективному использованию памяти при работе с большими данными. Кроме того, использование текстового представления времени в качестве ключа сортировки может привести к неожиданным результатам при работе с данными, имеющими одинаковые timestamps.

Улучшенный подход

Мы можем улучшить этот подход, используя встроенный алгоритм сортировки и храня данные в структуре данных, которая остается упорядоченной. Один из подходов к этому заключается в использовании виртуального списка и хранении данных в массиве или записи данных. При добавлении новых элементов в список мы просто добавляем их в конец массива или записи данных, а затем перестраиваем список, чтобы он оставался упорядоченным.

В качестве альтернативы мы можем отсортировать список в месте, используя рекурсивный алгоритм сортировки, такой как быстрая сортировка. Быстрая сортировка работает путем выбора опорного элемента из массива и перемещения всех элементов, которые меньше опорного, в одну сторону, а всех элементов, которые больше, в другую сторону. Затем мы рекурсивно применяем тот же процесс к двум частям массива.

Вот пример кода, демонстрирующий этот подход с использованием быстрой сортировки:

type
  TCompareIndicesFunction = reference to function(Index1, Index2: Integer): Integer;
  TExchangeIndicesProcedure = reference to procedure(Index1, Index2: Integer);

procedure QuickSort(Count: Integer; Compare: TCompareIndicesFunction;
  Exchange: TExchangeIndicesProcedure);
var
  I, J, P: Integer;
begin
  procedure Sort(L, R: Integer);
  var
    I, J, P: Integer;
  begin
    repeat
      I := L;
      J := R;
      P := (L+R) div 2;
      repeat
        while Compare(I, P) < 0 do inc(I);
        while Compare(J, P) > 0 do dec(J);
        if I <= J then
        begin
          if I <> J then
          begin
            Exchange(I, J);
            if P = I then
              P := J
            else if P = J then
              P := I;
          end;
          inc(I);
          dec(J);
        end;
      until I > J;
      if L < J then
        Sort(L, J);
      L := I;
    until I >= R;
  end;

  if Count > 0 then
    Sort(0, Count-1);
end;

var
  Compare: TCompareIndicesFunction;
  Exchange: TExchangeIndicesProcedure;

Compare :=
  function(Index1, Index2: Integer): Integer
  var
    dt1, dt2: TDateTime;
  begin
    dt1 := TFile.GetLastAccessTime(lb.Items[Index1]);
    dt2 := TFile.GetLastAccessTime(lb.Items[Index2]);
    if dt1 = dt2 then begin
      Result := 0;
    end else if dt2 < dt1 then begin
      Result := -1
    end else begin
      Result := 1;
    end;
  end;

Exchange :=
  procedure(Index1, Index2: Integer)
  begin
    lb.Items.Exchange(Index1, Index2);
  end;

QuickSort(lb.Count, Compare, Exchange);

Этот подход сортирует список в месте, что делает его более эффективным, чем создание нового экземпляра TStringList для каждой сортировки. Кроме того, использование numérique значения времени в качестве ключа сортировки делает результаты более предсказуемыми.

Заключение

В этой статье мы рассмотрели существующий подход к сортировке элементов в списке в убывающем порядке в Delphi XE8 и предложили улучшенный вариант с использованием встроенного алгоритма сортировки и хранения данных в структуре данных, которая остается упорядоченной. Использование быстрой сортировки и numérique значения времени в качестве ключа сортировки делает этот подход более эффективным и предсказуемым, чем существующий подход.

Создано по материалам из источника по ссылке.

В статье рассматривается вопрос сортировки элементов в списке в убывающем порядке в Delphi XE8 с предложением более эффективного подхода, использующего встроенный алгоритм сортировки и структуру данных, которая остается упорядоченной.

Комментарии и вопросы

Получайте свежие новости и обновления по Object Pascal, Delphi и Lazarus прямо в свой смартфон. Подпишитесь на наш Telegram-канал delphi_kansoftware и будьте в курсе последних тенденций в разработке под Linux, Windows, Android и iOS

:: Главная :: Сортировка и Фильтр ::