Algoritmo per ordinare un elenco di oggetti

Question

Dire di avere un elenco di oggetti. L'utente utilizza principalmente tutti gli oggetti quando sta lavorando. Come si può ordinare l'elenco degli oggetti, in modo che l'elenco si adatti all'ordine, gli utenti lo utilizzano principalmente? Quale algoritmo puoi usare per quello?

MODIFICA: molte risposte suggerivano di contare il numero di volte in cui un oggetto è stato utilizzato. Questo non funziona, perché tutti gli oggetti vengono utilizzati con la stessa quantità, solo in ordini diversi.

Answer 1

Aggiungi un elenco di data/ora di quando un utente accede a un oggetto. Ogni volta che un utente utilizza un oggetto, aggiunge un datetime.

Ora contate il numero di voci datetime nel vostro elenco che sono w (ora - x giorni) e ordinate per quello. È possibile eliminare i datet che sono> (ora - x giorni).

È possibile che un utente utilizzi articoli diversi in un mese, questo rifletterà tali cambiamenti.

Answer 2

All'interno dell'oggetto, mantenere un valore usedCount. Ogni volta che si utilizza l'oggetto, aumentare questo conteggio. allora si può semplicemente fare questo:

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

Answer 3

È possibile aggiungere un campo NUMBER_OF_VIEWS alla classe di oggetti, ++ ogni volta dell'oggetto lista usata e ordinare in base a quel campo. E dovresti rendere questo campo = 0 a tutti gli oggetti quando number_of_views a tutti gli oggetti è lo stesso ma non è 0.

Answer 4

Vorrei anche usare un contatore per ogni oggetto per monitorarne l'uso, ma invece di riordinare l'intero elenco dopo ogni utilizzo, consiglierei di ordinare l'elenco "localmente". Come in un bubble sort, vorrei semplicemente confrontare l'oggetto il cui contatore era appena aumentato con l'oggetto superiore, e scambiarli se necessario. Se lo scambio, vorrei quindi confrontare l'oggetto e il suo nuovo oggetto superiore e così via.

Tuttavia, non è molto diverso dai metodi precedenti se l'ordinamento è correttamente implementato.

Answer 5

Se la classe utente si presenta in questo modo:

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

E la classe Algo si presenta in questo modo:

class Algo 
{ 
    int usedCount; 
... 
} 

Si dovrebbe essere in grado di legare istanze specifiche dell'oggetto Algo all'oggetto User che consentono la registrazione di quanto spesso viene utilizzato. Al livello più elementare si serializzerebbe l'informazione in un file o in un flusso. Molto probabilmente vuoi un database per tenere traccia di ciò che viene utilizzato. Poi, quando si afferra la tua User e richiamare una funzione sort ordinate il algos param del User dal usedCount param di Algo

Answer 6

EDIT: Aggiunto un Ordine preferrence !!! guarda nel CODICE

Non mi piace l'ultimo metodo usato come ha detto Carra perché infligge molte modifiche di sorta che creano confusione.

il campo count_accessed è molto meglio, anche se penso che dovrebbe essere livellato a
quante volte l'utente ha effettuato l'accesso a questo elemento negli ultimi XX minuti/ore/giorni Etc ...

il meglio datastructure di ciò è sicuramente

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; 
     } 
    } 

Spero che questo aiuti ... è quasi sempre O (1) A proposito ...
mi ricorda un po 'il meccanismo sonno dei sistemi operativi

Answer 7

Sembra che tu voglia un cache. Spero che tu possa guardare gli algoritmi utilizzati da una cache e poi eliminare l'intera attività sul cambio di contesto ... c'è un algoritmo chiamato "sweep dell'orologio" ... ma meh potrebbe essere tutto troppo complesso per quello che stai cercando . Per andare in modo pigro, direi solo creare un hash di "cosa usata": num_of_uses o, nella tua classe, avere una var tu ++ ogni volta che l'oggetto viene usato.

Ogni tanto ordina l'hash di num_of_uses o degli oggetti in base al valore della loro variabile ++ 'd.

Answer 8

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

magari utilizzare OrderedMultiDictionary con l'usedCount come le chiavi e l'oggetto come il valore.

Answer 9

Vorrei tenere un conto corrente di quante volte è stato utilizzato l'oggetto e in quale ordine è stato utilizzato.

Quindi, se l'oggetto X è stato utilizzato per il terzo, calcolare la media con il conteggio parziale e utilizzare il risultato come posizione nell'elenco.

Ad esempio:

 
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) 

usi sarebbero quante volte l'utente ha utilizzato l'oggetto, l'ordine di utilizzo sarebbe una lista (o somma) di cui l'articolo viene utilizzato nell'ordine.

L'utilizzo di un elenco di ciascun ordine singolarmente potrebbe presentare alcuni problemi di prestazioni, pertanto è possibile che si desideri mantenere una somma delle posizioni. Se si mantiene una somma, basta aggiungere l'ordine a tale somma ogni volta che viene utilizzato l'oggetto.

Per calcolare la posizione, utilizzare la somma delle posizioni, divisa per il numero di utilizzi e la media. Tutto quello che dovresti fare a quel punto è ordinare la lista in base alla media.

Nell'esempio di cui sopra, si otterrebbe le seguenti medie (e fine):

 
Object X 1.8 
Object Z 2.0 
Object Y 2.3 

Answer 10

Quando un utente interagisce con un oggetto, salvare l'ID dell'oggetto precedente agito su su quel secondo oggetto in modo che hai sempre un puntatore all'oggetto usato prima di ogni oggetto dato.

Inoltre, memorizzare l'ID dell'oggetto utilizzato più di frequente in modo da sapere da dove iniziare.

Quando si crea l'elenco di oggetti da visualizzare, si inizia con quello archiviato come l'oggetto utilizzato più di frequente, quindi si cerca l'oggetto che ha l'ID dell'oggetto utilizzato per primo in esso memorizzato da visualizzare Il prossimo.