Una struttura di dati per gruppi di alberi.

I tentativi consentono una memorizzazione efficiente degli elenchi di elementi. I prefissi sono condivisi, quindi è efficiente nello spazio.

Sto cercando un modo simile per conservare gli alberi in modo efficiente. Vorrei poter verificare l'appartenenza e aggiungere elementi, sapendo se un determinato albero è una sottostruttura di alcuni alberi memorizzati o se esiste un albero memorizzato che è una sottostruttura dell'albero specificato è anche desiderabile.

Solitamente conserverei circa 500 alberi binari non bilanciati di altezza inferiore a 50.

MODIFICARE

La mia applicazione è una sorta di modello di controllo che utilizza una sorta di memoization. Immagina di avere uno stato e le seguenti formule: f = ϕ e g = ( ϕ ∨ ψ ) con ϕ essendo un subformula complesso, e immagina di voler prima sapere se f vale in s . Controllo se ϕ è valido e dopo un lungo processo ottengo che sia così. Ora voglio sapere se g vale in s . Vorrei ricordare il fatto che f vale e notare che g ⇒ $s$$f = \phi$$g = (\phi \vee \psi)$$\phi$$f$$s$$\phi$$g$$s$$f$$g \Rightarrow f$in modo che io possa derivare in s quasi all'istante. Al contrario, se ho dimostrato che g non tiene in t , allora voglio dire che f non tiene in t quasi all'istante.$g$$s$
$g$$t$$f$$t$

Possiamo costruire un ordine parziale sulle formule e avere iff g ⇒ f . Per ogni stato s , memorizziamo due serie di formule; L ( s ) memorizza le formule massime che detengono e l ( s ) memorizza le formule minime che non detengono. Ora dato uno stato s e una formula g , posso vedere se ∃ f ∈ L ( s ) , f ⇒ g , o se ∃ f ∈ l ( s $g \geq f$$g \Rightarrow f$$s$$L(s)$$l(s)$$s$$g$$\exists f \in L(s), f \Rightarrow g$ nel qual caso ho finito e so direttamente se g vale in s .$\exists f \in l(s), g \Rightarrow f$$g$$s$

Attualmente, e L sono implementate come liste e questo non è chiaramente ottimale perché ho bisogno per scorrere tutte le formule memorizzate singolarmente. Se le mie formule fossero sequenze, e se l'ordine parziale fosse "è un prefisso di", un trie potrebbe rivelarsi molto più veloce. Sfortunatamente le mie formule hanno una struttura ad albero basata su ¬ , ∧ , un operatore modale e proposizioni atomiche.$L$$l$$\neg, \wedge$

Come sottolinea @Raphael e @Jack, potrei sequenziare gli alberi, ma temo che non risolverebbe il problema perché l'ordine parziale a cui sono interessato non corrisponderebbe a "è un prefisso di".

Potresti voler dare un'occhiata a g-try . Questa è essenzialmente la struttura dei dati che stai cercando, ma progettata per l'uso con grafici generali anziché solo alberi. Pertanto, non sono sicuro che g-try abbia buone garanzie teoriche - penso che utilizzino un algoritmo di canonizzazione dei grafici come subroutine - ma in pratica sembrano funzionare bene.

(Non abbiate paura che il documento collegato riguardi "motivi di rete nelle reti biologiche": il g-trie è una struttura di dati astratti perfettamente valida per i grafici.)

Una forma speciale di questo è la persistenza : vedere i documenti Come rendere persistenti le strutture di dati di Driscoll, Sarnak, Sleator e Tarjan e ubicazione dei punti planari usando gli alberi di ricerca persistente di Sarnak e Tarjan, che memorizzano famiglie di alberi correlati.

Sembra un po 'come una foresta (foreste disgiunte ) ...

Ammortizza il costo dell'inserzione attraverso una tecnica chiamata unione per rango e l'operazione di ricerca usando la compressione del percorso . So che esiste anche una versione persistente di questa struttura sviluppata da Sylvain Conchon e Jean-Christophe Filliâtre, ma non ho idea se questa sia la stessa di quella menzionata da Jack ...

Che dire degli automi ad albero minimi ?

In "Purely Functional Data Structures" (1998), Chris Okasaki propone tentativi di alberi binari usando l'aggregazione dei tipi (10.3.2).

Non so se questo aiuti immediatamente; la soluzione fornita potrebbe non essere implementabile direttamente.

Nel linguaggio programmatore: se crei gli alberi da sottoespressioni / alberi / DAG comuni, avresti un bel modello compatto. Grafici aciclici così diretti. Quindi sarebbe sufficiente una serie di alberi.

albero di classe pubblica {operazione String; Tree [] subtrees;

public int compareTo(Tree rhs) {
    if (rhs == null) return false;
    int cmp = operation.compareTo(rhs.operation);
    if (cmp == 0) {
        cmp = Arrays.compareTo(subtrees, rhs.subtrees);
    }
    return cmp;
}

...}

Mappa commonSubExpressions = new HashMap ();

Tree get (String expressionSyntax) {Tree t = new Tree (); t.operation = ...; t.subtrees = ... chiamata ricorsiva per ottenere sottoespressioni; Albero t2 = commonSubExpressions.get (t); if (t2 == null) {t2 = t; commonSubExpressions.put (t2, t2); } restituisce t2; }}