Ordenar Array de Registro por campo determinado

[Bauhaus1975]

Hola, se me plantea una vez más esta duda y ya me gustaría hacerme con la función que lo implemente. Este tema se ha tratado alguna vez según he podido ver, pero no he visto que se haya dado un ejemplo o algo conciso que pueda usar.

Se trata de ordenar el array 'lista' por cualquiera de sus campos, según se quiera:

Código Delphi [-]
type
    item = record
                campo1 : double;
                campo2 : double;
            end;
    TLista = array of item;
var
    lista : TLista;

Aquí en el foro se planteo este mismo tema

-Y en esta web- he visto que plantean el tema usando un TList de punteros, pero ¿tengo que implementar un método 'Sort' de todas maneras?
¿Alguien tiene algún ejemplo válido para el caso?

Me han comentado que se podria usar algún componente no nativo como un 'JvMemoryDataset' de las Jedi, pero tengo el código muy dependiente a estas alturas de usar los tipos como he presentado (sin duda por mi falta de experiencia).

Gracias y un saludo.

[roman]

Si puedes usar un TList en lugar de un array te facilitarás la tarea. En un TList se guardan punteros, lo que significa que puedes guardar prácticamente cualquier cosa, en este caso, punteros a registros.

Tú no tienes que implementar el método Sort sino únicamente proveer a éste de una función de comparación:

Código Delphi [-]
function (Item1, Item2: Pointer): Integer;

Esta función debe devolver 1 si Item1 es menor que Item2, 0 si son iguales y -1 si Item1 es mayor que Item2. Entonces, en tu función tú simplemente tienes que examinar los registros que te pasan y comparar los campos que correponda.

// Saludos

[Bauhaus1975]

Hola Roman, gracias por tu respuesta.

Por cierto, he visto que había un post igual al mío después de publicar. Y tú mismo lo habías respondido, pero se detalla usar TObjectList (no sé si me trae algún beneficio).

Bueno, voy al grano. Tengo algunas dudas todavía, sin duda es falta de práctica con el lenguaje.

De momento intento hacer esto:

Código Delphi [-]
type
    TItem = record // NOTA: he cambiado el tipo de item a TItem
                campo1 : double;
                campo2 : double;
            end;
    TLista = TLIST; // nótese el cambio de tipo
var
    lista : TLista; 
begin
 
// Así creamos la lista:
lista := TList.Create;
 
// Así añadimos elementos
lista.Add(item); // Siendo item una variable de tipo 'TItem'
 
// Así ordenamos por campo 1, gracias a las funciones debajo definidas
list.Sort(@compararCampo1);
 
// Así ordenamos por campo 2, gracias a las funciones debajo definidas
list.Sort(@compararCampo2);
 
// Aquí definimos las funciones de ordenación (una por cada campo que necesite ser ordenado)
 
function compararCampo1(Item1, Item2: Pointer): Integer;
begin
  if TItem(Item1).campo1 > TItem(Item2).campo1 then
    result := 1
  else if TItem(Item1).campo1 < TItem(Item2).campo1 then
    result := -1
  else
    result := 0;
end;
// y la otra para ordenar por campo2
function compararCampo2(Item1, Item2: Pointer): Integer;
begin
  if TItem(Item1).campo2 > TItem(Item2).campo2 then
    result := 1
  else if TItem(Item1).campo2 < TItem(Item2).campo2 then
    result := -1
  else
    result := 0;
end;

¿Voy bien encaminado?
Ahora bien, para acceder a los datos tengo problemas con el 'Cast' de tipos, trato de hacer:

Código Delphi [-]
item := TItem(lista.Items[i]);
// Obteniendo el error de 'invalid typecast'

y no consigo evitar el error...

[roman]

Tendrías que completar tus tipos de datos con un apuntador al registro:

Código Delphi [-]
type
  PItem = ^TItem;
  TItem = record
    ...
  end;

Entonces, manejarías los elementos del TList así:

Código Delphi [-]
var
  Item: TItem;

begin
  // Agregar un item (la @ es para pasar un puntero al Item y no el Item en sí)
  Lista.Items.Add(@Item);

  // Tomar un item (haces el moldeo con PItem en lugar de TItem)
  Item := PItem(Lista.Items[i])^;
end;

// Saludos

[Bauhaus1975]

Hola de nuevo.
Entonces usando un puntero al registro. hmmm..., ¿quizá sea mejor usar un TObjectList?
y definir una clase que englobe al registro, lo digo por lo de ¿mejor usar objetos (nombres) que punteros?

Sí, ya sé que me pueden decir que mejor haber usado una clase para el tipo registro, pero resulta (lo típico) que el código ya está afectado de usar estos tipos.

Un saludo y gracias de nuevo.

[DarkMan]

Empezado por roman

Código Delphi [-]
 
var

  Item: TItem;
 
begin
  // Agregar un item (la @ es para pasar un puntero al Item y no el Item en sí)
  Lista.Items.Add(@Item);
 
  // Tomar un item (haces el moldeo con PItem en lugar de TItem)
  Item := PItem(Lista.Items[i])^;
end;

// Saludos

Una pequeña objección, este procedimiento sería incorrecto ya que Item es una variable local en este caso, y al ser un registro se elimina al finalizar la función. Al añadir su puntero a una lista de punteros, sólo podrás trabajar con él dentro de la propia función ya que después el item será eliminado. Una solución sería utilizar ficheros en lugar de Listas, utilizar una matriz global como habías comentado en el primer post, o cambiar el registro a clase.

Corregidme si me equivoco.

Un saludo.

[roman]

Es muy buena tu observación DarkMan. Habia puesto esa declaración ahí más que nada por fines informativos, para dejar claro el tipo de datos de Item. Pero lo cierto es que ni aun siendo una variable global tendría mucho sentido, pues no es cuestión de tener una variable por cada elemento de la lista.

Lo adecuado es crear dinámicamente los elementos que se insertan:

Código Delphi [-]
var
  Item: PItem; // Item es un puntero

begin
  New(Item);

  {
    Llenar ropiedades de Item:
    Item^.Campo1 := ...; 

    En delphi puede omitirse el operador de referencia ^
    Item.Campo2 := ...;
  }
  Lista.Add(Item); // Ojo, antes había puesto -incorrectamente- Lista.Items.Add
end;

Claro que, antes de destruir la lista, hay que recorrer sus elementos para liberar la memoria:

Código Delphi [-]
var
  I: Integer;

begin
  form I := 0 to Lista.Count - 1 do
    Dispose(Lista[i]);
end;

// Saludos

[Bauhaus1975]

Hola de nuevo y gracias a los dos por la ayuda.

Estoy ya implementando vuestros consejos, aunque como el código estaba muy extendido ya, me queda todavía, y no se aún si funciona. Me estoy planteando tener una función/ o método 'ordenar', que trate de manera aislada el TList para ordenar y luego devuelva una copia del TList pero pasado a 'array or record' que es lo que usa el resto de partes del programa.

Además, todavía me quedan algunas dudas...

1. Sobre la llamada a ordenar:

Código Delphi [-]
list.Sort(@compararCampo1);

¿Puedo pasar en vez de una función, un método de clase?
Also como '@self.compararCampo1'. Para no tener funciones sueltas. He probado pero no he conseguido salvar el error 'variable expected'.

2. Sobre el destruir items de la lista.

Empezado por roman

Código Delphi [-]
begin
  form I := 0 to Lista.Count - 1 do
          Dispose(Lista[i]);
end;

Roman, en vez de lo que comentas ¿no sería mejor lo siguiente?:

Código Delphi [-]
// O bien:
lista.Clear;
// O bien:
begin
  form I := 0 to Lista.Count - 1 do
          Dispose(Lista.items[i]);
          // incluso -> lista.Delete(i);
end;

También tengo otro problema, y es que tengo que almacenar cada Tlist que proceso en un array (array of TList). Resulta que cada vez que voy a procesar un nuevo TList, lo libero (reseteo), y pierdo lo que tenia almacenado en el array de TList de anteriores posiciones. Pero para no mezclar, esto lo trataré en un nuevo Post si es necesario.

Saludos.

[[Delphius]]

Empezado por Bauhaus1975

2. Sobre el destruir items de la lista.


Roman, en vez de lo que comentas ¿no sería mejor lo siguiente?:

Código Delphi [-]// O bien: lista.Clear; // O bien: begin form I := 0 to Lista.Count - 1 do Dispose(Lista.items[i]); // incluso -> lista.Delete(i); end;

Hola Bauhaus1975, no soy roman... mucho de lo que se vino hablando no tengo mucha idea, pero por lo que preguntas en el punto dos... creo que tengo la respuesta.

Si no me equivoco es indiferente. Tengo entendido que Items es la propiedad vectorial por defecto que tiene TList. Por ello es que es lo mismo: Lista[] que Lista.Items[].

Saludos,

[roman]

A ver, no nos confundamos. El método Lista.Delete borra un elemento de la lista, pero cada elemento es un puntero y Delete no libera la memoria a la que apunta el item, es decir, el registro creado con New. Por eso es necesario Dispose.

Igualmente, el método Lista.Clear únicamente borra cada item, pero sin liberar la memoria a la que apunta cada uno.

Por eso escribí: antes de destruir la lista. Es decir, tienes que hacer el Dispose de cada elemento, y posteriormente llamar a Lista.Free para borrar la lista y todos sus elementos.

En resumen: una cosa es el puntero y otra cosa es el bloque al que apunta el puntero.

// Saludos

[Bauhaus1975]

Hola de nuevo.
Ey Delphius, gracias por el apunte. Entendido, la liberación de memoria de cada elemento de la lista hay que programarla.

Y sobre pasar un método de clase ¿puede hacerse?:

Código Delphi [-]
// ¿Puede hacerse? Da error de variable expected
lista.Sort(@self.ordenarPorCampo);

Gracias y un saludo.