Hvordan slå sammen to BST er effektivt?

Hva om utflating både trær i sortert lister, sammenslåing listene og deretter opprette et nytt tre?

• Flat trær i sortert lister.
• Flett sorterte lister.
• Lag tre ut av fusjonerte listen.

IIRC, er at O ​​(n1 + n2).

Naaff svar med litt mer detaljer:

• Utflating en BST inn i en sortert liste er O (N)
  • Det er bare "in-order" iterasjon på hele treet.
  • Gjør det for begge er O (n1 + n2)
• Sammenslåing to sorterte lister er i en sortert liste er O (n1 + n2).
  • Hold pekere til hodene på begge listene
  • Velge den mindre hode og fremme dens peker
  • Dette er hvordan sammenslåingen av merge-sort verk
• Opprette en perfekt balansert BST fra en sortert liste er O (N)
  • Se kodebiten nedenfor for algoritme [1]
  • I vårt tilfelle sortert liste er av størrelse n1 + n2. så O (n1 + n2)
  • Den resulterende treet ville være den konseptuelle BST binær søking listen

Tre trinn fra O (n1 + n2) resultat i O (N1 + N2)

For n1 og n2 i den samme størrelsesorden, som er bedre enn O (n1 * log (N2))

[1] algoritme for å skape en balansert BST fra en sortert liste (i Python):

def create_balanced_search_tree(iterator, n):
    if n == 0:
        return None
    n_left = n//2
    n_right = n - 1 - n_left
    left = create_balanced_search_tree(iterator, n_left)
    node = iterator.next()
    right = create_balanced_search_tree(iterator, n_right)
    return {'left': left, 'node': node, 'right': right}

Jonathan,

Etter sortering, har vi en liste over lengde n1 + n2. Bygge et binært tre ut av det vil ta log (n1 + n2) tid. Dette er samme som flettingen slag, bare at det ved hver rekursiv trinn vi ikke har et O (n1 + n2) sikt, da vi har i flettesorteringsalgoritmen. Slik at tiden kompleksitet er log (n1 + n2).

Nå kompleksiteten av hele problemet er O (n1 + n2).

Også vil jeg si denne tilnærmingen er bra hvis to listene er sammenlignbar størrelse. Hvis størrelsene er ikke sammenlignbare så er det best å sette inn hver node i lite tre inn i et stort tre. Dette ville ta O (n1 * log (N2)) tid. For eksempel hvis vi har to trær en av størrelse 10 og en annen av størrelse 1024. Her n1 + n2 = 1,034 hvor som n1log (n2) = 10 * 10 = 100. Så tilnærmingen har til å være avhengig av størrelsen på de to trær.

O (n1 * log (N2)) er den gjennomsnittlige fall, selv om vi har to flette noen usortert listen inn i en BST. Vi er ikke å utnytte det faktum at listen er sortert liste eller en BST.

Ifølge meg kan anta en BST har N1-elementer og andre har n2 elementer. Nå konvertere en BST inn i en Ordnet Array liste L1 i O (n1).

Fusjonerte BST (BST, Array)

if (Array.size == 0) retur BST if (Array.size == 1) sette inn elementet i BST. returnere BST;

Finn indeksen i matrisen som venstre element <BST.rootnode og rette element> = BST.rootnode si Index. if (BST.rootNode.leftNode == null) // dvs. ingen venstre noden {sett hele rekken fra Index til 0 til venstre fra BST og} else {Fusjonert BST (BST.leftNode, Array {0 til indeks})}

if (BST.rootNode.rightNode == null) // dvs. ingen rett node {sett hele rekken fra Index til Array.size til høyre fra BST} else {Fusjonert BST (BST.rightNode, Array {indeksen til å Array.size} )}

tilbake BST.

Denne algoritmen vil ta << tid enn O (n1 * log (N2)) som hver gang vi er partisjone array og BST å håndtere deloppgave.

Ideen er å bruke iterativ inorder traversering. Vi bruker to hjelpe stabler for to BSTs. Siden vi trenger å skrive ut elementene i sortert form, når vi får et mindre element fra noen av trærne, skriver vi det. Hvis elementet er større, så vi skyve den tilbake til stakken for neste iterasjon.