Hoe ze efficiënt fuseren twee BST's?

Hoe zit het met het afvlakken van beide bomen in naargelang lijsten, het samenvoegen van de lijsten en dan het creëren van een nieuwe boom?

• Plat bomen in gesorteerd lijsten.
• Samenvoegen gesorteerde lijsten.
• Maak een boom uit samengevoegde lijst.

IIRC, dat is O (n1 + n2).

antwoord Naaff's met een beetje meer informatie:

• Afvlakking een BST in een gesorteerde lijst is O (N)
  • Het is gewoon "in-order" iteratie op de hele boom.
  • Doet het voor beide is O (n1 + n2)
• Het samenvoegen van twee gesorteerde lijsten is in een gesorteerde lijst is O (n1 + n2).
  • Houd verwijzingen naar de hoofden van beide lijsten
  • Kies de kleinere kop en voortgang van de aanwijzer
  • Dit is hoe het samenvoegen van merge-sort werken
• Het creëren van een perfect uitgebalanceerde BST uit een gesorteerde lijst is O (N)
  • De waarde in het midden zou de wortel en recurse zijn.
  • In ons geval de gesorteerde lijst is van de grootte n1 + n2. dus O (n1 + n2)
  • De resulterende boom zou de conceptuele BST binaire doorzoeken van de lijst zijn

Drie stappen van O (n1 + n2) resulteren in O (n1 + n2)

Voor N1 en N2 van dezelfde orde van grootte, dat is beter dan O (n1 * log (N2))

Jonathan,

Na het sorteren, hebben we een lijst met lengte n1 + n2. Het bouwen van een binaire boom uit het zal inloggen (n1 + n2) tijd in beslag nemen. Dit is hetzelfde als merge soort, alleen bij elke recursieve stap slaan we een O (n1 + n2) term zoals we hebben merge sort-algoritme. Dus de tijd complexiteit is log (n1 + n2).

Nu is de complexiteit van het hele probleem is O (n1 + n2).

Ook zou ik zeggen dat deze aanpak is goed als er twee lijsten zijn vergelijkbare grootte. Als de maten zijn niet vergelijkbaar, dan is het best om elk knooppunt van de kleine boom te voegen in een grote boom. Dit zou O (n1 * log (N2)) tijd in beslag nemen. Bijvoorbeeld als we twee bomen een van maat 10 en een andere van omvang 1024. Hier n1 + n2 = 1034 waar hij als n1log (N2) = 10 * 10 = 100. Dus aanpak moet afhangen van de grootte van de twee bomen.

O (n1 * log (N2)) is de gemiddelde case scenario zelfs als we 2 samenvoegen elke ongesorteerde lijst in een BST. We zijn niet gebruik te maken van het feit dat de lijst is gesorteerde lijst of een BST.

Volgens mij Laten we aannemen dat een BST heeft n1 elementen en andere heeft n2 elementen. Nu zetten een BST in een gesorteerde array List L1 in O (n1).

Samengevoegd BST (BST, Array)

if (Array.size == 0) return BST if (Array.size == 1) Plaats het element in de BST. terugkeer BST;

Zoek de index in de array waarvan de linker- element <BST.rootnode en rechts element> = BST.rootnode zeggen Index. if (BST.rootNode.leftNode == null) // ie geen links knooppunt {voeren alle array-index op 0 in een linker van BST en} else {Samengevoegd BST (BST.leftNode, Array {0 naar Index})}

if (BST.rootNode.rightNode == null) // ie Geen recht knooppunt {voeren alle array-index naar Array.size naar rechts van BST} else {Samengevoegd BST (BST.rightNode, Array {Index Array.size} )}

terug BST.

Dit algoritme zal << tijd dan O (n1 * log (N2)) nemen elke keer als we zijn het verdelen van de array en BST naar het deelprobleem te behandelen.

Het idee is iteratieve inorder traversal te gebruiken. We maken gebruik van twee extra stacks voor twee BSTS. Daar moeten we de elementen in gesorteerde vorm af te drukken, wanneer we krijgen een kleinere element uit een van de bomen, drukken we het. Als het element groter duw we terug te stapelen voor de volgende iteratie.