delphi - Cómo hacer una clasificación similar a Excel por A, luego por B en una TObjectList<> usando múltiples comparadores

generics sorting

Question

Acabo de comenzar a usar genéricos y actualmente tengo problemas para clasificar en varios campos.

Caso:
Tengo una PeopleList como TObjectList<TPerson> y quiero poder realizar una función de clasificación similar a Excel, seleccionando un campo de clasificación a la vez, pero manteniendo la clasificación anterior tanto como sea posible.

EDITAR: debe ser posible cambiar la secuencia de clasificación de campo en tiempo de ejecución. (Es decir, en un escenario, el usuario desea el ordenamiento A, B, C; en otro escenario, quiere B, A, C; en otro A, C, D)

Digamos que tenemos una lista de personas sin clasificar:

Lastname     Age
---------------------
Smith        26
Jones        26
Jones        24
Lincoln      34

Ahora si lo ordeno por Apellido:

Lastname ▲   Age
---------------------
Jones        26
Jones        24
Lincoln      34
Smith        26

Entonces si ordeno por Edad, quiero esto:

Lastname ▲   Age ▲
---------------------
Jones        24
Jones        26
Smith        26
Lincoln      34

Para hacer esto, he hecho dos comparadores: uno TLastNameComparer y uno TAgeComparer.

Ahora llamo

PeopleList.Sort(LastNameComparer)
PeopleList.Sort(AgeComparer)

Ahora mi problema es que esto no produce la salida que quiero, pero

Lastname ?   Age ?
---------------------
Jones        24
Smith        26
Jones        26
Lincoln      34

donde Smith, 26 aparece ante Jones, 26 en cambio. Así que parece que no mantiene la clasificación anterior.

Sé que puedo hacer un solo comparador que compare tanto Apellido como Edad, pero el problema es que luego tengo que hacer comparadores para cada combinación de los campos presentes en TPerson.

¿Es posible hacer lo que quiero usando varios TComparers o cómo puedo lograr lo que quiero?

Actualización de año nuevo

Solo para referencia a futuros visitantes, este es (casi) el código que estoy usando ahora.

Primero hice una clase base TSortCriterion<T> y un TSortCriteriaComparer<T> para poder usarlos en varias clases en el futuro. He cambiado el Criterio y la lista a TObject y TObjectList respectivamente, ya que me resultó más fácil si la lista de objetos controla automáticamente la destrucción del Criterio.

  TSortCriterion<T> = Class(TObject)
    Ascending: Boolean;
    Comparer: IComparer<T>;
  end;

  TSortCriteriaComparer<T> = Class(TComparer<T>)
  Private
    SortCriteria : TObjectList<TSortCriterion<T>>;
  Public
    Constructor Create;
    Destructor Destroy; Override;
    Function Compare(Const Right,Left : T):Integer; Override;
    Procedure ClearCriteria; Virtual;
    Procedure AddCriterion(NewCriterion : TSortCriterion<T>); Virtual;
  End;

implementation

{ TSortCriteriaComparer<T> }

procedure TSortCriteriaComparer<T>.AddCriterion(NewCriterion: TSortCriterion<T>);
begin
  SortCriteria.Add(NewCriterion);
end;

procedure TSortCriteriaComparer<T>.ClearCriteria;
begin
  SortCriteria.Clear;
end;

function TSortCriteriaComparer<T>.Compare(Const Right, Left: T): Integer;
var
  Criterion: TSortCriterion<T>;
begin
  for Criterion in SortCriteria do begin
    Result := Criterion.Comparer.Compare(Right, Left);
    if not Criterion.Ascending then
      Result := -Result;
    if Result <> 0 then
      Exit;
  end;
end;

constructor TSortCriteriaComparer<T>.Create;
begin
  inherited;
  SortCriteria := TObjectList<TSortCriterion<T>>.Create(True);
end;

destructor TSortCriteriaComparer<T>.Destroy;
begin
  SortCriteria.Free;
  inherited;
end;

Finalmente, para usar los criterios de clasificación: (esto es solo por el ejemplo, ya que la lógica de crear el orden de clasificación realmente depende de la aplicación):

Procedure TForm1.SortList;
Var
  PersonComparer : TSortCriteriaComparer<TPerson>; 
  Criterion : TSortCriterion<TPerson>;
Begin
  PersonComparer := TSortCriteriaComparer<TPerson>.Create;
  Try
    Criterion:=TSortCriterion<TPerson>.Create;
    Criterion.Ascending:=True;
    Criterion.Comparer:=TPersonAgeComparer.Create
    PersonComparer.AddCriterion(Criterion);
    Criterion:=TSortCriterion<TPerson>.Create;
    Criterion.Ascending:=True;
    Criterion.Comparer:=TPersonLastNameComparer.Create
    PersonComparer.AddCriterion(Criterion);
    PeopleList.Sort(PersonComparer);
    // Do something with the ordered list of people.
  Finally
    PersonComparer.Free;  
  End;  
End;

Answer 1

Ponga sus criterios de clasificación en una lista que incluya la dirección para ordenar y la función que se usará para comparar elementos. Un registro como este podría ayudar:

type
  TSortCriterion<T> = record
    Ascending: Boolean;
    Comparer: IComparer<T>;
  end;

A medida que el usuario configura el orden deseado, rellene la lista con las instancias de ese registro.

var
  SortCriteria: TList<TSortCriterion>;

El miembro del Comparer se referirá a las funciones que ya ha escrito para comparar en función del nombre y la edad. Ahora escribe una única función de comparación que se refiera a esa lista. Algo como esto:

function Compare(const A, B: TPerson): Integer;
var
  Criterion: TSortCriterion<TPerson>;
begin
  for Criterion in SortCriteria do begin
    Result := Criterion.Comparer.Compare(A, B);
    if not Criterion.Ascending then
      Result := -Result;
    if Result <> 0 then
      Exit;
  end;
end;

Answer 2

Si tiene un algoritmo de clasificación estable , puede aplicar cada comparador en orden inverso , y el resultado será una lista ordenada en el orden que desee. Las clases de la lista de Delphi usan una ordenación rápida, que no es una ordenación estable. Necesitará aplicar su propia rutina de clasificación en lugar de las integradas.

Answer 3

Su problema es que está realizando dos clases separadas. Debe realizar una única ordenación y usar lo que se conoce como ordenamiento léxico . Debe usar un comparador que compare el campo primario y luego, solo si la clave primaria se compara igual, continúa comparando la clave secundaria. Me gusta esto:

Result := CompareStr(Left.Name, Right.Name);
if Result=0 then
  Result := Left.Age-Right.Age;

Este enfoque puede extenderse para atender un número arbitrario de claves.

En su actualización de la pregunta, agrega el requisito de que la prioridad de la clave se determinará en el tiempo de ejecución. Puedes hacer esto con una función de comparación como esta:

function TMyClass.Comparison(const Left, Right: TPerson): Integer;
var
  i: Integer;
begin
  for i := low(FSortField) to high(FSortField) do begin
    Result := CompareField(Left, Right, FSortField[i]);
    if Result<>0 then begin
      exit;
    end;
  end;
end;

Aquí FSortField es una matriz que contiene identificadores para los campos, en orden decreciente de prioridad. Por FSortField[0] tanto, FSortField[0] identifica la clave primaria, FSortField[1] identifica la clave secundaria y así sucesivamente. La función CompareField compara el campo identificado por su tercer parámetro.

Así que la función CompareField podría ser así:

function CompareField(const Left, Right: TPerson; Field: TField): Integer;
begin
  case Field of
  fldName:
    Result := CompareStr(Left.Name, Right.Name);
  fldAge:
    Result := Left.Age-Right.Age;
  //etc.
  end;
end;