Eso es ordenar varias columnas, típicamente suele ser preciso para el uso de controles tipo grid con múltiples columnas.
En general en esos caso conviene usar un algoritmo que sea estable, para que en el caso de que haya ítems con igual valor, permanezcan en el orden primigenio (uno respecto de otros que comparten esa igualdad de valor). Al caso quicksort no es estable, hay quien usa Mergesort, que sí lo es o en su defecto bubblesort, que también lo es, pero imagínate lo lentísimo que pueda ser cuando la cantidad de elementos crece...
Otra cuestión general es que dichos controles suelen tener en efecto una estructura, donde cada columna es representada por un campo en la estructura, con lo que en efecto al ordenar (tal como te comenta Mafus), quedan ordenadas todas las columnas al tiempo. La desventaja clara de este método, es que impide o mejor dicho complica, la posibilidad de añadido o inserción dinamica de columnas.
En estos casos (cuando se pretende que el número de columnas sea variable) se abandona la estructura en favor de un array para cada fila, donde cada elemento de la fila ya no es un campo de una estructura sino un ítem en el array. Luego acaba siendo un array de arrays, o bien un array bidimensional. Si es bidimensional cualquier cambio de tamaño (en algunas de las dos dimensiones), supone una caída en el rendimiento...
Cuando he realizado algún grid que deseaba que tuviera la característica de añadido y eliminación dinámica, suele ser necesario disponer en efecto de columnas (separadas), donde cada columna es un array independiente (representada con una clase por ejemplo), y precisamente el ordenamiento lo he realizado siempre con Quicksort.
Como Quicksort, no es estable y esta característica es deseable (si ordenas por una columna y luego por otras que retenga el orden previo para ítems que en la columna actual siendo ordenada tengan igual valor (sin importar si en la previa columna ordenada no sucedía esto)), pues se debe modificar ligeramente quicksort, para que el orden permita ser estable.
He aquí el pseudocódigo de una variación de quicksort, para que permita ordenar diferentes array ligados entre sí por su índice inicial y que además sean estables...
En realidad, el cambio en la funcion, son pocos:
1 - Se limita a añadir un parámetro más (un array de mismo tamaño).
2 - Declarar una variable temporal para el intercambio de valores de este array adicional y.
3 - Añadir una línea de código extra, para el intercambio, cuando dos items deban ser intercambiados de orden.
Es precisamente el array 'ixEstable', quien se encarga de ir manteniendo la coherencia del cambio de ubicación... donde fue a a parar cada item. El 'antes' tenía por valores precisamente su orden: 0,1,2,3,4... size-1, el 'después' viene reflejado a la salida que depende del desorden que tenía el array a ordenar..
funcion QuicksortEst(datos(), ixEstable(), min, max)
entero j, k, Pivot, tmpD, tmpX
j = Min: k = Max
Pivot = Datos((j + k) \ 2) //tomamos como pivot el valor en medio del rango entre min y max.
hacer mientras (j <= k)
hacer mientras (Datos(j) < Pivot); j += 1; repetir
hacer mientras (Datos(k) > Pivot); k -= 1; repetir
si (j <= k)
Si (j < k)
// intercambia los datos. En realidad conviene el puntero al dato, para poder utilizar distintos tipos de datos en la función).
// luego tmpd = datos(k), puede ser el puntero o el valor al elemento en datos(k)... entiéndase según necesidades.
tmpD = Datos(k); Datos(k) = Datos(j); Datos(j) = tmpD
// con cada intercambio en el orden, intercambiamos los valores del array adicional, que nos ayudará a mantener la estabilidad.
tmpX = IxEstable(k); IxEstable(k) = IxEstable(j); IxEstable(j) = tmpX
fin si
j += 1; k -= 1
sino
salir del bucle
fin si
Repetir
si (Min < k) llamada a QuicksortEst(Datos, IxEstable, Min, k)
si (Max > j) llamar a QuicksortEst(Datos, IxEstable, j, Max)
fin funcion
Eso sí para el resto de columnas, el orden está basado en el array adicional, luego cada array debe ser recorrido para establecer dicho nuevo orden, así el costo total de ordenar será la suma del QuickSort, + el recorrido para el intercambio para mantener la estabilidad en cada array.
Una función adicional, debe alojar la llamada a la función quicksort modificada que se ha puesto antes, aunque previamente a dicha llamada, debe establecer el valor al array 'ixEstable', y luego tras el orden reasocia el resto de arrays conforme al orden que mantiene este array 'orden'.
Dejo esta parte a tu ingenio... a ver si logras sacarlo, si pasado el tiemo no lo logras (no me refiero a 10 minutos, ni 4 horas) avisa, que te ponga un pseudocódigo para dicha función...
...dejo eso sí, una captura de muestra:
Autor
En línea
