Algoritmo para ordenar una lista de objetos

Question

Supongamos que tiene una lista de objetos. El usuario usa principalmente todos los objetos cuando está trabajando. ¿Cómo se puede ordenar la lista de objetos para que la lista se adapte al orden y los usuarios usen principalmente? ¿Qué algoritmo puedes usar para eso?

EDITAR: Muchas respuestas sugirieron contar el número de veces que se utilizó un objeto. Esto no funciona, porque todos los objetos se usan la misma cantidad, solo en diferentes órdenes.

Answer 1

Agregue una lista de las fechas de cuando un usuario accede a un objeto. Cada vez que un usuario usa un objeto, agregue una fecha y hora.

Ahora solo cuente el número de entradas datetime en su lista que son w (ahora - x días) y ordene por eso. Puede eliminar las fechas que son> (ahora - x días).

Es posible que un usuario utilice diferentes elementos en un mes, esto reflejará esos cambios.

Answer 2

Dentro de su objeto, mantenga usedCount. Siempre que se use el objeto, aumente este conteo. , entonces puede simplemente hacer esto:

objects.OrderByDescending(o => o.UsedCount); 

Answer 3

Usted puede agregar un campo NUMBER_OF_VIEWS a su clase de objeto, ++ que cada vez que se usa la lista y ordenar del objeto por ese campo. Y debe hacer que este campo = 0 para todos los objetos cuando number_of_views en todos los objetos sea igual pero no 0.

Answer 4

También usaría un contador para cada objeto para monitorear su uso, pero en lugar de reordenar toda la lista después de cada uso, recomendaría simplemente ordenar la lista "localmente". Al igual que en una ordenación de burbuja, simplemente compararía el objeto cuyo contador acaba de aumentar con el objeto superior, y lo cambiaría si fuera necesario. Si se intercambia, entonces compararía el objeto y su nuevo objeto superior, y así sucesivamente.

Sin embargo, no es muy diferente de los métodos anteriores si el ordenamiento se implementa correctamente.

Answer 5

Si la clase del usuario se ve así:

class User 
{ 
    Collection<Algo> algosUsed = new List<Algo>();  //Won't compile, used for explanation 
    ... 
} 

Y tu clase Algo se ve así:

class Algo 
{ 
    int usedCount; 
... 
} 

Usted debe ser capaz de unirse a instancias específicas del objeto Algo al objeto User que permiten la grabación de la frecuencia con que se usa. En el nivel más básico, serializaría la información en un archivo o una secuencia. Lo más probable es que desee una base de datos para realizar un seguimiento de lo que se está utilizando. Luego, cuando se ase su User e invocar una función sort usted pide el parámetro de algosUser por el parámetro de usedCountAlgo

Answer 6

EDIT: Se ha añadido una Orden preferrence !!! mira en el CÓDIGO

No me gusta el último método utilizado como dijo Carra porque inflige muchos cambios de tipo que es confuso.

el campo count_accessed es mucho mejor, aunque creo que se debe nivelar a
cuántas veces el usuario accedió a este elemento en los últimos XX minutos/horas/días Etc ...

la mejor estructura de datos para la que es sin duda

static TimeSpan TIME_TO_LIVE; 
    static int userOrderFactor = 0; 

    LinkedList<KeyValuePair<DateTime, int>> myAccessList = new  LinkedList<KeyValuePair<DateTime, int>>(); 

    private void Access_Detected() 
    { 
     userOrderFactor++; 
     myAccessList.AddLast(new KeyValuePair<DateTime, int>(DateTime.Now, userOrderFactor)); 
     myPriority += userOrderFactor; // take total count differential, so we dont waste time summing the list 
    } 



    private int myPriority = 0; 
    public int MyPriority 
    { 
     get 
     { 
      DateTime expiry = DateTime.Now.Subtract(TIME_TO_LIVE); 
      while (myAccessList.First.Value.Key < expiry) 
      { 
       myPriority += myAccessList.First.Value.Value; // take care of the Total Count 
       myAccessList.RemoveFirst(); 
      } 
      return myPriority; 
     } 
    } 

Espero que esto ayude ... casi siempre es O (1) Por cierto ...
me recuerda un poco del mecanismo del sueño de los sistemas operativos

Answer 7

Parece que quieres un caché. Supongo que podrías ver los algoritmos que usa un caché y luego sacar todo el asunto sobre el cambio de contexto ... hay un algoritmo llamado "barrido del reloj" ... pero eso podría ser demasiado complejo para lo que estás buscando. . Para ir de la manera perezosa, yo diría que solo hagas un hash de "cosa usada": num_of_uses o, en tu clase, tienes una var you ++ cada vez que se usa el objeto.

De vez en cuando, ordene el hash por num_of_uses o los objetos por el valor de su variable ++ 'd.

Answer 8

De https://stackoverflow.com/a/2619065/1429439:

usar tal OrderedMultiDictionary con el usedCount como las claves y el objeto como el valor.

Answer 9

Me gustaría mantener un conteo de cuántas veces se utilizó el objeto, y en qué orden se utilizó.

Por lo tanto, si el objeto X se usó en tercer lugar, promedielo con el conteo de ejecución y usa el resultado como su posición en la lista.

Por ejemplo:

 
Item  Uses  Order of Use 
--------------------------------------- 
Object X 10  1,2,3,1,2,1,3,1,2,2 (18) 
Object Y 10  3,1,2,3,3,3,1,3,3,1 (23) 
Object Z 10  2,3,1,2,1,2,2,2,2,3 (20) 

usos serían el número de veces que el usuario utiliza el objeto, el orden de uso sería una lista (o suma) de donde se utiliza la posición de la orden.

El uso de una lista de cada pedido individualmente podría tener algunos problemas de rendimiento, por lo que es posible que desee mantener una suma de las posiciones. Si mantiene una suma, simplemente agregue la orden a esa suma cada vez que use el objeto.

Para calcular la posición, entonces simplemente usaría la suma de las posiciones, dividida por el número de usos y tendría su promedio. Todo lo que tendrías que hacer en ese punto es ordenar la lista por el promedio.

En el ejemplo anterior, se obtendría los siguientes promedios (y fin):

 
Object X 1.8 
Object Z 2.0 
Object Y 2.3 

Answer 10

Cuando un usuario interactúa con un objeto, guardar el ID del objeto anterior realizada por el emisor objeto de modo que la segunda que siempre tiene un puntero al objeto utilizado antes de cualquier objeto dado.

Además, almacene el ID del objeto usado más frecuentemente para que sepa por dónde empezar.

Cuando está creando su lista de objetos para mostrar, comienza con la que ha almacenado como el primer objeto usado con más frecuencia y luego busca el objeto que tiene almacenada la identificación del primer objeto usado para mostrar siguiente.