Come unire due alberi binari di ricerca mantenendo la proprietà della BST?
Se decidiamo di prendere ogni elemento da un albero e inserirlo nel l'altro, la complessità di questo metodo sarebbe O(n1 * log(n2)), in cui n1è il numero di nodi dell'albero (diciamo T1), che abbiamo a spacco, ed n2è il numero di nodi di l'altro albero (diciamo T2). Dopo questa operazione una sola BST ha n1 + n2nodi.
La mia domanda è: possiamo fare meglio di O (n1 * log (n2))?
Che dire appiattimento entrambi gli alberi in liste ordinate, fondendo le liste e quindi la creazione di un nuovo albero?
IIRC, che è O (n1 + n2).
La risposta di Naaff con un po 'più particolari:
Tre passi di O (n1 + n2) risultato in O (n1 + n2)
Per n1 e n2 dello stesso ordine di grandezza, che è meglio di O (n1 * log (n2))
Jonathan,
Dopo la cernita, abbiamo una lista di lunghezza n1 + n2. Costruire un albero binario fuori ci vorrà log (n1 + n2) tempo. Questo è lo stesso come merge sort, solo che ad ogni passo ricorsivo si voleva avere un O (n1 + n2) termine come abbiamo in algoritmo merge sort. Così la complessità temporale è log (n1 + n2).
Ora la complessità di tutto il problema è O (n1 + n2).
Inoltre direi che questo approccio è buono se due liste sono di dimensioni comparabili. Se le dimensioni non sono comparabili, allora è consigliabile inserire ogni nodo del piccolo albero in un grande albero. Questo richiederà O (n1 * log (n2)) tempo. Per esempio se abbiamo due alberi uno di dimensioni 10 e uno di dimensione 1024. Qui n1 + n2 = 1034 dove come n1log (n2) = 10 * 10 = 100. Quindi approccio deve dipendere dalle dimensioni dei due alberi.
O (n1 * log (n2)) è lo scenario medio caso, anche se abbiamo 2 merge qualsiasi elenco non ordinato in un BST. Noi non stiamo utilizzando il fatto che la lista è lista ordinata o un BST.
Secondo me Consente di assumere un BST presenta elementi n1 e n2 altro ha elementi. Ora convertire un BST in un array ordinato elenco L1 a O (n1).
BST fusa (BST, Array)
if (Array.size == 0) return BST se (Array.size == 1) inserire l'elemento nel BST. tornare BST;
Trova l'indice nella matrice cui elemento sinistra <BST.rootnode ed elemento di destra> = BST.rootnode dicono Index. if (BST.rootNode.leftNode == null) // cioè n nodo fianco {inserire tutta la matrice da Index a 0 nella sinistra della BST e} else {BST Fusione (BST.leftNode, Array {0 all'indice})}
if (BST.rootNode.rightNode == null) // cioè n nodo destra {inserire tutta la matrice da indice per Array.size in destra di BST} else {Fusione BST (BST.rightNode, Array {N} per Array.size )}
tornare BST.
Questo algoritmo avrà << tempo di O (n1 * log (n2)) come ogni volta che ci troviamo di partizionamento della matrice e BST per gestire il sottoproblema.
L'idea è quella di utilizzare iterativa ordine simmetrico. Usiamo due pile ausiliari per due BST. Dal momento che abbiamo bisogno di stampare gli elementi in forma ordinata, ogni volta che si ottiene un elemento più piccolo da qualsiasi degli alberi, il risultato della stampa di esso. Se l'elemento è maggiore, allora spingerlo indietro per impilare per la successiva iterazione.
