Hogyan lehet egyesíteni két BST által hatékonyan?

Mi a helyzet a simító mindkét fák rendezve felsorolja, összevonása a listákat, majd hozzon létre egy új fát?

• A görbületek fák rendezve felsorolja.
• Merge kiválogatott listákat.
• Készítsen fa ki egyesített listán.

IIRC, hogy a jelentése O (n1 + n2).

Naaff válasza egy kicsit bővebben:

• Lapítása egy BST egy rendezett listát O (N)
  • Ez csak „in-order” ismétlés az egész fa.
  • Csinálni mindkét jelentése O (n1 + n2)
• Egyesülő két sorba rendezett listák egyetlen rendezett lista O (n1 + n2).
  • Tartsa mutatókat a feje mindkét lista
  • Pick a kisebb fej és előre a mutató
  • Így az egyesítés a merge-sort munkák
• Létrehozása tökéletesen kiegyensúlyozott BST egy rendezett lista O (N)
  • Az érték a középső lenne a gyökér, és recurse.
  • A mi esetünkben a rendezett lista méretű n1 + n2. így O (n1 + n2)
  • Az így kapott fa lenne a fogalmi BST bináris keresést a lista

Három lépés O (n1 + n2) eredményeként O (n1 + n2)

N1 és N2 azonos nagyságrendű, ez jobb, mint O (n1 * log (n2))

Jonathan,

A válogatás után, van egy lista hossza n1 + n2. Épület egy bináris fa ki fog tartani log (n1 + n2) idő. Ez ugyanaz, mint a merge sort, csak hogy minden rekurzív lépésben szokás van egy O (n1 + n2) kifejezés van az egyesítés rendezési algoritmusnak. Tehát az idő komplexitás log (n1 + n2).

Most összetettsége az egész problémát O (n1 + n2).

Továbbá azt mondják, hogy ez a megközelítés jó, ha két lista hasonló méretű. Ha a méret nem összehasonlítható, akkor a legjobb, hogy helyezze minden csomópontnak a kis fa egy nagy fa. Ez O (n1 * log (n2)) időben. Például ha van két fa egyik mérete 10 és a másik méret 1024 Itt n1 + n2 = 1034, ahol, mint n1log (n2) = 10 * 10 = 100. Tehát a megközelítésnek, hogy függ a mérete a két fa.

O (n1 * log (n2)) az az átlagos esetben is, ha van 2 egyesítés bármely rendezetlen listát egy BST. Nem vagyunk kihasználva azt a tényt, hogy a lista lista vagy BST.

Szerint nekem tételezzük fel, egy BST van n1 és egyéb elemek is n2 elemekkel. Most átalakítani egy BST egy rendezett tömbben List L1 O (n1).

Egyesített BST (BST, Array)

ha (Array.size == 0) visszatérési BST, ha (Array.size == 1) helyezze az elem a BST. visszatérés BST;

Keresse az index a tömb, amelynek baloldali elem <BST.rootnode és jobbra elem> = BST.rootnode mondani Index. ha (BST.rootNode.leftNode == null) // azaz nincs bal csomópont {illessze a tömb összes a Index 0 bal- BST és} else {Egyesített BST (BST.leftNode, Array {0 index})}

ha (BST.rootNode.rightNode == null) // azaz nincs joga csomópont {illessze a tömb összes a Index Array.size be jobbra BST} else {Egyesített BST (BST.rightNode, Array {Index Array.size} )}

visszatér BST.

Ez az algoritmus kerül << időt igényel, mint O (n1 * log (n2)), mint minden alkalommal, amikor particionálásakor a tömb és a BST kezelni a részkérdésnek.

Az ötlet az, hogy az iteratív inorder bejárása. Az általunk használt két kiegészítő stack két BSTs. Mivel mi kell nyomtatni az elemek rendezett formában, amikor kapunk egy kisebb eleme minden a fák, kiírjuk azt. Ha az elem nagyobb, akkor tolja vissza verem a következő iteráció.