Comment fusionner deux arbres binaires de recherche maintenant la propriété de BST?
Si nous décidons de prendre chaque élément d'un arbre et l' insérer dans l'autre, la complexité de cette méthode serait O(n1 * log(n2)), où n1est le nombre de nœuds de l'arbre ( par exemple T1), que nous avons dédoublées, et n2est le nombre de nœuds de l'autre arbre ( par exemple T2). Après cette opération , seule BST a n1 + n2noeuds.
Ma question est: peut-on faire mieux que O (n1 * log (n2))?
Qu'en est-il aplatir les arbres dans des listes triées, la fusion des listes et puis en créant un nouvel arbre?
IIRC, qui est O (n1 + n2).
La réponse de Naaff avec un peu plus de détails:
Trois étapes de O (n1 + n2) résultat en O (n1 + n2)
Pour n1 et n2 du même ordre de grandeur, qui est mieux que O (log n1 * (n2))
Jonathan,
Après le tri, nous avons une liste de longueur n1 + n2. Construction d'un arbre binaire sur ce phénomène va se connecter (n1 + n2). Ce même est comme une sorte de fusion, seulement à chaque étape récursive nous avons l'habitude d'un O (n1 + n2) terme que nous avons dans l'algorithme de tri de fusion. Ainsi, la complexité temporelle est log (n1 + n2).
Maintenant, la complexité du problème est O (n1 + n2).
De plus, je dirais que cette approche est bonne si deux listes sont de taille comparable. Si les dimensions ne sont pas comparables alors il est préférable d'insérer chaque nœud du petit arbre dans un grand arbre. Cela prendrait O (n1 * log (n2)) temps. Par exemple, si nous avons deux arbres un de la taille 10 et un autre de taille 1024. Ici n1 + n2 = 1034 où, comme n1log (n2) = 10 * 10 = 100. Donc, l'approche doit dépendre de la taille des deux arbres.
O (n1 * log (n2)) est le scénario moyen de cas même si nous avons 2 fusion une liste non triés dans un BST. Nous n'utilisons pas le fait que la liste est la liste triée ou BST.
Selon moi Lets supposer un BST a n1 éléments et d'autres éléments a n2. Maintenant convertir un BST dans un tableau de la liste triée L1 en O (n1).
Fusionné BST (BST, Array)
if (Array.size == 0) return BST if (Array.size == 1) insérer l'élément dans le BST. retourner BST;
Trouvez l'index dans le tableau dont l'élément gauche <BST.rootnode et élément droit> = BST.rootnode dire Index. if (BST.rootNode.leftNode == null) // par exemple Aucun nœud gauche {insérer tout le tableau de l'index à 0 en gauche de BST et} else {Fusionné BST (BST.leftNode, Array {0} à l'index)}
if (BST.rootNode.rightNode == null) // ie pas de noeud droit {insérer tout le tableau de l'index à Array.size en droit de BST} else {Fusionné BST (BST.rightNode, Array {Index Array.size} )}
retour BST.
Cet algorithme prendra le temps que << O (n1 * log (n2)) comme à chaque fois que nous le partitionnement du tableau et BST pour gérer le sous-problème.
L'idée est d'utiliser itérative afinde traversal. Nous utilisons deux piles auxiliaires pour deux BSTS. Depuis que nous avons besoin d'imprimer les éléments sous forme triée, chaque fois que nous obtenons un plus petit élément de l'un des arbres, nous l'imprimer. Si l'élément est plus, nous repoussez à pile pour la prochaine itération.
