Quale albero binario autobilanciante consiglieresti?

Sto imparando Haskell e come esercizio sto facendo alberi binari. Avendo creato un normale albero binario, voglio adattarlo per bilanciarmi da solo. Così:

• Qual è il più efficiente?
• Qual è la più facile da implementare?
• Qual è il più usato?

Ma soprattutto, quale mi consigliate?

Presumo che questo appartenga qui perché è aperto al dibattito.

Ti consiglierei di iniziare con un albero rosso-nero o un albero AVL .

L'albero rosso-nero è più veloce per l'inserimento, ma l'albero AVL ha un leggero margine per le ricerche. L'albero AVL è probabilmente un po 'più facile da implementare, ma non molto sulla base della mia esperienza.

L'albero AVL assicura che l'albero sia bilanciato dopo ogni inserimento o cancellazione (nessun sottoalbero ha un fattore di equilibrio maggiore di 1 / -1, mentre l'albero rosso-nero assicura che l'albero sia ragionevolmente bilanciato in qualsiasi momento.

Vorrei prendere in considerazione un'alternativa se stai bene con strutture di dati randomizzate : Skip Lists .

Da un punto di vista di alto livello, è una struttura ad albero, tranne per il fatto che non è implementato come un albero ma come un elenco con più livelli di collegamenti.

Otterrai inserimenti / ricerche / eliminazioni O (log N) e non dovrai occuparti di tutti quei difficili casi di ribilanciamento.

Non ho mai considerato di implementarli in un linguaggio funzionale, e la pagina di Wikipedia non ne mostra nessuno, quindi potrebbe non essere facile (scritto sull'immutabilità)

Se vuoi iniziare con una struttura relativamente semplice (sia gli alberi AVL che gli alberi rosso-neri sono complicati), un'opzione è un passo - chiamato come una combinazione di "albero" e "mucchio".

Ogni nodo ottiene un valore "prioritario", spesso assegnato casualmente quando viene creato il nodo. I nodi sono posizionati nella struttura in modo da rispettare l'ordinamento delle chiavi e in modo da rispettare l'ordinamento simile a heap dei valori di priorità. Un ordinamento simile a un heap significa che entrambi i figli di un genitore hanno priorità inferiori rispetto al genitore.

EDIT cancellato "all'interno dei valori chiave" sopra: la priorità e l'ordinamento delle chiavi si applicano insieme, quindi la priorità è significativa anche per chiavi univoche.

È una combinazione interessante. Se le chiavi sono uniche e le priorità sono uniche, esiste una struttura ad albero unica per qualsiasi set di nodi. Anche così, inserti ed eliminazioni sono efficienti. A rigor di termini, l'albero può essere sbilanciato al punto in cui è effettivamente un elenco collegato, ma questo è estremamente improbabile (come con gli alberi binari standard), anche per casi normali come le chiavi inserite in ordine (a differenza degli alberi binari standard).

Qual è il più efficiente?

Vago e difficile rispondere. Le complessità computazionali sono tutte ben definite. Se questo è ciò che intendi per efficienza, non c'è un vero dibattito. In effetti, tutti i buoni algoritmi vengono forniti con prove e fattori di complessità.

Se intendi "tempo di esecuzione" o "utilizzo della memoria", dovrai confrontare le implementazioni effettive. Quindi lingua, tempo di esecuzione, sistema operativo e altri fattori entrano in gioco, rendendo difficile rispondere alla domanda.

Qual è la più facile da implementare?

Vago e difficile rispondere. Alcuni algoritmi possono sembrare complessi per te, ma per me banali.

Qual è il più usato?

Vago e difficile rispondere. Prima c'è il "da chi?" parte di questo? Solo Haskell? Che dire di C o C ++? In secondo luogo, c'è il problema del software proprietario in cui non abbiamo accesso alla fonte per fare un sondaggio.

Ma soprattutto, quale mi consigliate?

Presumo che questo appartenga qui perché è aperto al dibattito.

Corretta. Poiché i tuoi altri criteri non sono molto utili, questo è tutto ciò che otterrai.

È possibile ottenere la fonte per un gran numero di algoritmi ad albero. Se vuoi imparare qualcosa, potresti semplicemente implementare tutti quelli che riesci a trovare. Invece di chiedere una "raccomandazione", basta raccogliere tutti gli algoritmi che riesci a trovare.

Ecco la lista:

http://en.wikipedia.org/wiki/Self-balancing_binary_search_tree

Ne sono definiti sei popolari. Inizia con quelli.

Se sei interessato agli alberi di Splay, esiste una versione più semplice di quelli che credo siano stati descritti per la prima volta in un articolo di Allen e Munroe. Non ha le stesse garanzie prestazionali, ma evita le complicazioni nell'affrontare il riequilibrio "zig-zig" vs "zig-zag".

Fondamentalmente, durante la ricerca (comprese le ricerche di un punto di inserimento o di un nodo da eliminare), il nodo che si trova viene ruotato direttamente verso la radice, dal basso verso l'alto (ad es. Quando esce una funzione di ricerca ricorsiva). Ad ogni passo, selezioni una singola rotazione a sinistra o a destra a seconda che il bambino che vuoi fare un altro passo verso la radice sia il bambino giusto o il bambino a sinistra (se ricordo correttamente le mie direzioni di rotazione, questo è rispettivamente).

Come per gli alberi Splay, l'idea è che gli oggetti a cui si è avuto accesso di recente siano sempre vicini alla radice dell'albero, così rapidamente di nuovo accesso. Essendo più semplici, questi alberi Allen-Munroe ruotano su radice (ciò che li chiamo - non conosco il nome ufficiale) può essere più veloce, ma non hanno la stessa garanzia di prestazioni ammortizzata.

Una cosa: poiché questa struttura di dati, per definizione, muta anche per le operazioni di ricerca, probabilmente dovrebbe essere implementata monadicamente. IOW forse non è adatto alla programmazione funzionale.

Un albero bilanciato molto semplice è un albero AA . È invariante è più semplice e quindi più facile da attuare. Per la sua semplicità, le sue prestazioni sono ancora buone.

Come esercizio avanzato, puoi provare a utilizzare i GADT per implementare una delle varianti di alberi bilanciati il ​​cui invariante è applicato dal tipo di sistema.