Wie zwei BST effizient fusionieren?

Was über die beiden Bäume in sortierten Listen Abflachung, die Listen Zusammenführung und dann einen neuen Baum zu schaffen?

• Flatten Bäume in sortierten Listen.
• Merge sortierten Listen.
• Erstellen Baum aus vereinigter Liste.

IIRC, dh O (n1 + n2).

Naaff Antwort mit ein wenig mehr Details:

• ein BST in eine sortierte Liste Abflachen ist O (N)
  • Es ist nur „in Ordnung“ Iteration auf dem ganzen Baum.
  • Tun es für beide O (n1 + n2)
• Zusammenführen von zwei sortierten Listen wird in eine sortierte Liste ist O (n1 + n2).
  • Halten Sie Zeiger auf die Köpfe der beiden Listen
  • Suchen Sie sich die kleineren Kopf und voran seinen Zeiger
  • Dies ist, wie die Zusammenführung von Merge-Art Werken
• perfekt ausgewogenen BST aus einer sortierten Liste zu erstellen ist O (N)
  • Der Wert in der Mitte würde die Wurzel und recurse sein.
  • In unserem Fall ist die sortierte Liste der Größe n1 + n2. so O (n1 + n2)
  • Der resultierende Baum würde die begriffliche BST binärer, die Liste der Suche

Drei Stufen von O (n1 + n2) Ergebnis in O (n1 + n2)

Für n1 und n2 der gleichen Größenordnung, das ist besser als O (n1 * log (n2))

Jonathan,

Nach dem Sortieren, haben wir eine Liste der Länge n1 + n2. Der Aufbau eines binären Baum aus es dauern wird, log (n1 + n2) Zeit. Dies ist die gleiche wie merge Sortieren, nur, daß bei jedem rekursiven Schritt haben wir nicht einen O (n1 + n2) Begriff, wie wir in merge Sortieralgorithmus haben. So ist die Zeitkomplexität ist log (n1 + n2).

Nun ist die Komplexität des ganzen Problems ist O (n1 + n2).

Ich würde auch sagen, dieser Ansatz ist gut, wenn zwei Listen vergleichbare Größe sind. Wenn die Größen nicht vergleichbar sind, dann ist es am besten jeden Knoten des kleinen Baumes in einen großen Baum einzufügen. Dies würde O (n1 * log (n2)) Zeit in Anspruch nehmen. Zum Beispiel, wenn wir zwei Bäumen eine der Größe 10 und eine andere Größe 1024. Hier n1 + n2 = 1034, wo als n1log (n2) = 10 * 10 = 100. Also Ansatz auf die Größen der beiden Bäume hängen hat.

O (n1 * log (n2)) ist der durchschnittliche Fall, auch wenn wir 2 merge jede unsortierte Liste in eine BST haben. Wir nutzen nicht die Tatsache, dass die Liste ist sortierte Liste oder ein BST.

Nach mir Nehmen wir an, ein BST hat n1 Elemente und andere n2 Elemente. Jetzt ein BST in ein sortiertes Array Liste L1 in O (n1) konvertieren.

Fusionierte BST (BST, Array)

if (Array.size == 0) return BST if (Array.size == 1) einfügen, das Element in dem BST. Rückkehr BST;

Finden Sie den Index im Array, dessen linkes Element <BST.rootnode und rechtes Element> = BST.rootnode sagen Index. if (BST.rootNode.leftNode == null) // dh keine linken Knoten {einzufügen alle Array-Index von 0 bis in eine linke und von BST} else {Fusioniert BST (BST.leftNode, Array {0} zum Index)}

if (BST.rootNode.rightNode == null) // dh keine rechten Knoten {einzufügen alle Array-Index von in rechts von BST Array.size} else {Fusioniert BST (BST.rightNode, Array {Index Array.size} )}

Rückkehr BST.

Dieser Algorithmus nimmt << Zeit als O (n1 * log (n2)) wie jedes Mal, wenn wir Partitionierung der Anordnung und BST die Subproblem zu behandeln.

Die Idee ist, iterative Inorder Traversal zu verwenden. Wir verwenden zwei Hilfsstapel für zwei BSTs. Da wir die Elemente in sortierter Form drucken müssen, wenn wir ein kleineres Element aus einem der Bäume zu erhalten, drucken wir es. Wenn das Element größer ist, dann schieben wir für die nächste Iteration zu stapeln zurück.