¿Cómo combinar dos BST de manera eficiente?

¿Qué tal aplanar ambos árboles en listas ordenadas, fusionar las listas y luego crear un nuevo árbol?

• Acoplar árboles en listas ordenadas.
• Fusionar listas ordenadas.
• Crear árbol fuera de la lista fusionada.

IIRC, que es O (n1 + n2).

La respuesta de Naaff con un poco más de detalles:

• Aplanar una BST en una lista ordenada es O (N)
  • Es solo una iteración "en orden" en todo el árbol.
  • Hacerlo para ambos es O (n1 + n2)
• La fusión de dos listas ordenadas en una lista ordenada es O (n1 + n2).
  • Mantenga los punteros a la cabeza de ambas listas
  • Elija la cabeza más pequeña y avance su puntero
  • Así es como funciona la fusión de merge-sort
• La creación de un BST perfectamente equilibrado a partir de una lista ordenada es O (N)
  • El valor en el medio sería la raíz y recurse.
  • En nuestro caso, la lista ordenada es de tamaño n1 + n2. entonces O (n1 + n2)
  • El árbol resultante sería el BST conceptual de búsqueda binaria en la lista

Tres pasos de O (n1 + n2) dan como resultado O (n1 + n2)

Para n1 y n2 del mismo orden de magnitud, es mejor que O (n1 * log (n2))

Jonathan,

Después de la clasificación, tenemos una lista de longitud n1 + n2. La construcción de un árbol binario de que tomará registro de tiempo (n1 + n2). Este es el mismo que de combinación de tipo, solo que en cada paso recursivo que no tendrá un O (n1 + n2) término como tenemos en el algoritmo de combinación de tipo. Por lo que la complejidad del tiempo es log (n1 + n2).

Ahora la complejidad de todo el problema es O (n1 + n2).

También diría que este enfoque es bueno si dos listas son tamaño comparable. Si los tamaños no son comparables, entonces es mejor para insertar cada nodo del árbol pequeño en un gran árbol. Esto llevaría tiempo O (n1 * log (N2)). Por ejemplo si tenemos dos árboles, uno de 10 y otro de tamaño de tamaño 1024. Aquí n1 + n2 = 1034 donde como n1log (N2) = 10 * 10 = 100. Así enfoque tiene que depender de los tamaños de los dos árboles.

O (n1 * log (N2)) es el escenario del caso promedio, incluso si tenemos 2 de combinación de cualquier lista sin ordenar en una BST. No estamos utilizando el hecho de que la lista está lista ordenada o una BST.

Según yo Vamos a suponer una BST tiene elementos n1 y n2 otro tiene elementos. Ahora convertir un BST en una matriz ordenada la lista L1 en O (n1).

BST Fusionada (BST, Array)

si (Array.size == 0) retorno BST si (Array.size == 1) insertar el elemento en el BST. volver BST;

Encontrar el índice de la matriz cuyo elemento izquierdo <BST.rootnode y el elemento derecho> = BST.rootnode dicen Índice. si (BST.rootNode.leftNode == null) // es decir, ningún nodo izquierda {insertar toda la matriz a partir de Índice a 0 en la izquierda de BST y} else {BST Fusionada (BST.leftNode, Array {0 al índice})}

si (BST.rootNode.rightNode == null) // es decir, ningún nodo derecha {insertar toda la matriz a partir de Índice a Array.size en derecho de BST} else {BST Fusionada (BST.rightNode, Array {Índice de Array.size} )}

volver BST.

Este algoritmo se llevará << tiempo que O (n1 * log (N2)) ya que cada vez estamos partición de la matriz y BST para manejar el subproblema.

La idea es utilizar iterativo finde recorrido. Utilizamos dos pilas auxiliares para dos BSTs. Puesto que necesitamos para imprimir los elementos en forma ordenada, cada vez que tenemos un elemento más pequeño de cualquiera de los árboles, lo imprimimos. Si el elemento es mayor, entonces nos empuje hacia atrás para apilar para la siguiente iteración.