Esiste una struttura ad albero o un algoritmo per mescolare i livelli di un albero?

Question

Ho quello che penso sia un problema interessante.

Fondamentalmente, ho un elenco di elementi, in cui ogni elemento ha un insieme fisso di meta-dati, di valori diversi.

Ad esempio:

• Articolo 1: {type = "text", autore = "Utente A", a cura Data = "03/03/2003"}
• Articolo 2: {Type = "Tabella", Autore = "Utente A", Data di modifica = "04/05/2006"}
• Elemento 3: {Tipo = "Immagine", Autore = "Utente B", Data di revisione = "05/05/2005" }
• Articolo 4: {type = "text", autore = "utente B", a cura Data = "05/07/2007"}

Ora, così com'è, quell'elenco di elementi è appiattito e presentato in una tabella.

Tuttavia, vorremmo trovare un modo per consentire agli utenti di sfogliarlo in un albero, ma con la maggiore flessibilità di poter "ruotare" l'ordine, ciascuno dei tag dei meta-dati appare nell'albero.

Quindi, inizialmente potrebbe apparire come:

Items 
+ Table 
    + User A 
    + 04/05/2006 
     -> Item 2 
    -> Item 2 
    -> Item 2 
+ Text 
    + User A 
    + 03/03/2003 
     -> Item 1 
    -> Item 1 
    + User B 
    + 05/07/2007 
     -> Item 4 
    -> Item 4 
    -> Item 1 
    -> Item 4 
+ Image 
    .. 

Tuttavia, supponiamo invece, un utente vuole capovolgere rotonda e visualizzare tutti gli elementi relativi a un particolare utente:

Items 
+ User A 
    + Text 
    + Table 
    -> Item 1 
    -> Item 2 
+ User B 
    + Image 
    + Text 
    -> Item 3 
    -> Item 4 

E così sopra.

Spero che abbia senso.

Quindi, quello che mi chiedo, quindi, è se esiste un approccio migliore per ottenere questo a basso costo? Il risultato di ogni 'flip/shuffle/pivot' è ben rappresentato in un albero, quindi ovviamente il primo pensiero è che quando un utente richiede di cambiare la rappresentazione, può essere generato un nuovo albero dell'elenco di elementi come richiesto. Tuttavia, speravo che potesse esserci un modo migliore, semplicemente ruotando un singolo albero ecc.

Inoltre, questo è qualcosa che potrebbe essere fatto a livello computazionale in JavaScript sul browser dell'utente, se il backend dovesse semplicemente restituire un elenco di articoli?

Molte grazie & cordiali saluti,

Jamie

Answer 1

Loro modo vorrei andare in giro per risolvere questo è quello di definire un elemento della lista che lookgs qualcosa di simile:

public class Item 
{ 
    string NodeName {get; set;} 
    string Url {get; set;} 
    List<Item> Children {get; set;} 
} 

Questo è C# -code, ma l'idea dovrebbe essere applicabile in qualsiasi linguaggio che supporti gli oggetti. Ora la tua lista deve solo supportare un tipo di lista, e questo è un elenco di Item quindi tutto quello che devi fare è trovare un modo per trasformare i tuoi dati in un tale elenco.

Answer 2

Si desidera presentare elementi in una struttura ad albero, ma con una profondità di albero variabile e il cambio di ramificazione: dubito che una struttura ad albero sia effettivamente ciò che si desidera.

Penso che dovresti considerare invece che il mondo è piatto (come nel tuo tavolo). Un database javascript potrebbe aiutare (c'è http://taffydb.com/)

ancora valutando il mondo è piatto, si potrebbe anche creare una funzione di firma che restituisce una stringa

separator="µ"; //TODO Find something better 
function signature() { 
    return item.Type + separator + item.Author + separator + item.EditedDate; 
} 


assert(item1.signature == "TextµUser Aµ03/03/2003") 

Poi memorizzare gli oggetti in un dizionario semplice utilizzo di questo firma come chiave.

E quindi, è possibile eseguire una corrispondenza delle espressioni regolari sui tasti per ottenere gli oggetti desiderati. Innanzitutto, modificare la funzione di firma per restituire "([^ separatore] +)" se la proprietà dell'oggetto corrispondente non è definita.

assert ({Type="Text"}.signature() == "Textµ[^µ]+µ[^µ]+") 

function find(filterItem) { 
    retval= = new generic.list(); 
    for (var k in dict.keys()) { 
    if (k.match(regexp)) { 
     retval.add(dcit[k]); 
    } 
    } 
} 

Non ho idea se sia più veloce rispetto a sfogliare tutti gli elementi.