Si el recorrido en preorden de un árbol de búsqueda binaria es de 6, 2, 1, 4, 3, 7, 10, 9, 11, cómo sacar el recorrido posterior a la orden?
Pre-fin de recorrido posterior a la orden
votos
14
11 respuestas
votos 8
8
Para pre-pedido = dar salida a los valores de un árbol binario en el orden del nodo actual, entonces el subárbol izquierdo, luego el subárbol derecho.
Posterioridad a la orden = dar salida a los valores de un árbol binario en el orden del subárbol izquierdo, luego el subárbol derecho, el nodo actual.
En un sistema binario de búsqueda de árbol, los valores de todos los nodos del subárbol izquierdo son menores que el valor del nodo actual; y por igual para el subárbol derecho. Por lo tanto si se conoce el comienzo de un vertedero de pre-orden de un árbol binario de búsqueda (es decir, el valor de su nodo raíz), se puede descomponer fácilmente todo el vertedero en el valor del nodo raíz, los valores de los nodos del subárbol izquierdo, y los valores de los nodos del subárbol derecho.
Para dar salida al árbol en post-orden, se aplica la recursividad y la reordenación de salida. Esta tarea se deja al lector.
votos 23
23
Se le da el recorrido en preorden del árbol, que se construye haciendo: salida, izquierda travesía, travesía derecha.
A medida que el recorrido posterior a la orden viene de una BST, se puede deducir el recorrido en orden (Traverse izquierda, de salida, de desplazamiento derecha) del recorrido posterior a fin de ordenar los números. En su ejemplo, el recorrido en orden es 1, 2, 3, 4, 6, 7, 9, 10, 11.
A partir de dos recorridos entonces podemos construir el árbol original. Vamos a usar un ejemplo más simple para esto:
- Pre-orden: 2, 1, 4, 3
- En orden: 1, 2, 3, 4
El recorrido en preorden nos da la raíz del árbol como en el 2.-orden de recorrido nos dice 1 cae en el sub-árbol izquierdo y 3, 4 cae en el derecho de sub-árbol. La estructura de la sub-árbol izquierdo es trivial ya que contiene un solo elemento. recorrido pre-ordenar el derecho de sub-árbol se deduce mediante la adopción de la orden de los elementos en esta sub-árbol de la pre-orden de recorrido originales: 4, 3. En esto conocemos el origen de la derecha sub-árbol es 4 y del recorrido en orden (3, 4) sabemos que 3 cae en el sub-árbol izquierdo. Nuestro árbol final es el siguiente:
2
/ \
1 4
/
3
Con la estructura de árbol, podemos obtener el recorrido posterior a fin de recorrer el árbol: travesía a la izquierda, atravesar la derecha, la salida. Para este ejemplo, el recorrido post-orden es 1, 3, 4, 2.
Para generalizar el algoritmo:
- El primer elemento en el recorrido en preorden es la raíz del árbol. Elementos, menos de la raíz forman el sub-árbol de la izquierda. Elementos mayores que forman la raíz del subárbol derecho.
- Encuentra la estructura de los sub-árboles izquierdo y derecho utilizando el paso 1 con un recorrido en preorden que consta de los elementos que resultó ser en ese sub-árbol colocado en el orden en que aparecen en el recorrido antes de la orden original.
- Recorrer el árbol resultante en la post-fin de obtener el recorrido posterior a la orden asociada con el recorrido de pre-orden dado.
Usando el algoritmo anterior, el recorrido post-pedido asociado con el recorrido pre-orden en la pregunta es: 1, 3, 4, 2, 9, 11, 10, 7, 6. Obtención de allí se deja como un ejercicio.
votos 3
3
Sobre la base de la respuesta de Ondrej Tucny. Válido para BST Sólo
ejemplo:
20
/ \
10 30
/\ \
6 15 35
Preorder = 20 10 6 15 30 35
post = 6 15 10 35 30 20
Para una BST, En traversal Preorder; primer elemento del array es 20. Esta es la raíz de nuestro árbol. Todos los números en serie que son menor que 20 forman su subárbol izquierdo y mayores números forman subárbol derecho.
//N = number of nodes in BST (size of traversal array)
int post[N] = {0};
int i =0;
void PretoPost(int pre[],int l,int r){
if(l==r){post[i++] = pre[l]; return;}
//pre[l] is root
//Divide array in lesser numbers and greater numbers and then call this function on them recursively
for(int j=l+1;j<=r;j++)
if(pre[j]>pre[l])
break;
PretoPost(a,l+1,j-1); // add left node
PretoPost(a,j,r); //add right node
//root should go in the end
post[i++] = pre[l];
return;
}
Por favor, corríjanme si hay algún error.
votos 2
2
se le da los resultados de recorrido de pre-orden. a continuación, poner los valores a un árbol binario de búsqueda adecuado y sólo tienes que seguir el algoritmo de recorrido posterior a fin de que el BST obtenido.
votos 0
0
Sé que esto es viejo, pero no hay una solución mejor.
No tenemos para reconstruir una BST para obtener el posterioridad a la orden de la pre-orden.
Aquí es un simple código Python que lo hace de forma recursiva:
import itertools
def postorder(preorder):
if not preorder:
return []
else:
root = preorder[0]
left = list(itertools.takewhile(lambda x: x < root, preorder[1:]))
right = preorder[len(left) + 1:]
return postorder(left) + postorder(right) + [root]
if __name__ == '__main__':
preorder = [20, 10, 6, 15, 30, 35]
print(postorder(preorder))
Salida:
[6, 15, 10, 35, 30, 20]
explicación :
Sabemos que estamos en pre-orden. Esto significa que la raíz está en el índice 0de la lista de los valores de la BST. Y sabemos que los elementos siguientes de la raíz son:
- en primer lugar: los elementos, menos de la
root, que pertenecen al subárbol izquierdo de la raíz - segunda: los elementos mayores que el
root, que pertenecen al subárbol derecho de la raíz
A continuación, simplemente llamamos recursivamente la función en ambos subárboles (que todavía están en pre-orden) y luego la cadena left + right + root(que es el post-orden).
votos 0
0
Si se le ha dado orden previo y desea convertirlo en orden posterior. A continuación, usted debe recordar que en un BST con el fin siempre dan los números en orden ascendente order.Thus que tienen tanto finde, así como el orden previo para construir un árbol.
hacer un pedido: 6, 2, 1, 4, 3, 7, 10, 9, 11
en orden: 1, 2, 3, 4, 6, 7, 9, 10, 11
Y su orden posterior: 1 3 4 2 9 11 10 7 6
votos 0
0
Aquí recorrido en preorden de un árbol binario de búsqueda se da en la matriz. Por lo que el primero elemento de la matriz pre-orden va a raíz del BST.We se encuentra la parte izquierda de la BST y parte derecha de BST.All el elemento de matriz pre-orden es menor que la raíz se dejará Todo nodo y el elemento en el pre -order matriz es mayor que la raíz será nodo derecho.
#include <bits/stdc++.h>
using namespace std;
int arr[1002];
int no_ans = 0;
int n = 1000;
int ans[1002] ;
int k = 0;
int find_ind(int l,int r,int x){
int index = -1;
for(int i = l;i<=r;i++){
if(x<arr[i]){
index = i;
break;
}
}
if(index == -1)return index;
for(int i =l+1;i<index;i++){
if(arr[i] > x){
no_ans = 1;
return index;
}
}
for(int i = index;i<=r;i++){
if(arr[i]<x){
no_ans = 1;
return index;
}
}
return index;
}
void postorder(int l ,int r){
if(l < 0 || r >= n || l >r ) return;
ans[k++] = arr[l];
if(l==r) return;
int index = find_ind(l+1,r,arr[l]);
if(no_ans){
return;
}
if(index!=-1){
postorder(index,r);
postorder(l+1,index-1);
}
else{
postorder(l+1,r);
}
}
int main(void){
int t;
scanf("%d",&t);
while(t--){
no_ans = 0;
int n ;
scanf("%d",&n);
for(int i = 0;i<n;i++){
cin>>arr[i];
}
postorder(0,n-1);
if(no_ans){
cout<<"NO"<<endl;
}
else{
for(int i =n-1;i>=0;i--){
cout<<ans[i]<<" ";
}
cout<<endl;
}
}
return 0;
}
votos 0
0
Como sabemos preorden sigue padres, izquierda, derecha serie.
Para construir el árbol tenemos que seguir unos pocos pasos- básica:
su pregunta consistirá en la serie 6, 2,1,4,3,7,10,9,11
puntos-:
- En primer número de serie será la raíz (padre), es decir 6
2.Find el número que es mayor que 6 por lo que en esta serie 7 es primero mayor número en esta serie nodo tan a la derecha será a partir de aquí y de izquierda a este número (7) es sus subárboles izquierdos.
6
/ \
2 7
/ \ \
1 4 10
/ / \
3 9 11
3.same forma sigue la regla básica de BST es decir, a la izquierda, raíz, haga
la serie de orden post será L, R, N es decir 1,3,4,2,9,11,10,7,6
votos 0
0
Este es el código de orden previo a la orden posterior recorrido en Python. Estoy construyendo un árbol para que pueda encontrar cualquier tipo de recorrido
def postorder(root):
if root==None:
return
postorder(root.left)
print(root.data,end=" ")
postorder(root.right)
def preordertoposorder(a,n):
root=Node(a[0])
top=Node(0)
temp=Node(0)
temp=None
stack=[]
stack.append(root)
for i in range(1,len(a)):
while len(stack)!=0 and a[i]>stack[-1].data:
temp=stack.pop()
if temp!=None:
temp.right=Node(a[i])
stack.append(temp.right)
else:
stack[-1].left=Node(a[i])
stack.append(stack[-1].left)
return root
class Node:
def __init__(self,data):
self.data=data
self.left=None
self.right=None
a=[40,30,35,80,100]
n=5
root=preordertoposorder(a,n)
postorder(root)
# print(root.data)
# print(root.left.data)
# print(root.right.data)
# print(root.left.right.data)
# print(root.right.right.data)
votos 0
0
Aquí está el código completo)
class Tree:
def __init__(self, data = None):
self.left = None
self.right = None
self.data = data
def add(self, data):
if self.data is None:
self.data = data
else:
if data < self.data:
if self.left is None:
self.left = Tree(data)
else:
self.left.add(data)
elif data > self.data:
if self.right is None:
self.right = Tree(data)
else:
self.right.add(data)
def inOrder(self):
if self.data:
if self.left is not None:
self.left.inOrder()
print(self.data)
if self.right is not None:
self.right.inOrder()
def postOrder(self):
if self.data:
if self.left is not None:
self.left.postOrder()
if self.right is not None:
self.right.postOrder()
print(self.data)
def preOrder(self):
if self.data:
print(self.data)
if self.left is not None:
self.left.preOrder()
if self.right is not None:
self.right.preOrder()
arr = [6, 2, 1, 4, 3, 7, 10, 9, 11]
root = Tree()
for i in range(len(arr)):
root.add(arr[i])
print(root.inOrder())
votos 0
0
Ya que, se trata de un árbol de búsqueda binaria, el recorrido en orden será siempre ser los elementos ordenados. (Izquierda <raíz <derecha)
Por lo tanto, se puede escribir fácilmente sus resultados de recorrido en orden primero, que es: 1,2,3,4,6,7,9,10,11
dado Pre-orden: 6, 2, 1, 4, 3, 7, 10, 9, 11
En orden: a la izquierda, raíz, haga Pre-orden: raíz, izquierda, derecha después de la orden: izquierda, derecha, raíz
Ahora, llegamos desde la pre-orden, que es la raíz 6.
Ahora, usando en orden y los resultados pre-orden: Paso 1:
6
/ \
/ \
/ \
/ \
{1,2,3,4} {7,9,10,11}
Paso 2: la próxima raíz es, utilizando el recorrido en orden, 2:
6
/ \
/ \
/ \
/ \
2 {7,9,10,11}
/ \
/ \
/ \
1 {3,4}
Paso 3: De manera similar, al lado de la raíz es de 4:
6
/ \
/ \
/ \
/ \
2 {7,9,10,11}
/ \
/ \
/ \
1 4
/
3
Paso 4: 3 al lado de la raíz es, sin otro elemento es restante para estar en forma en el árbol niño por "3". Teniendo en cuenta el próximo 7 de raíz que ahora,
6
/ \
/ \
/ \
/ \
2 7
/ \ \
/ \ {9,10,11}
/ \
1 4
/
3
Paso 5: A continuación de la raíz es de 10:
6
/ \
/ \
/ \
/ \
2 7
/ \ \
/ \ 10
/ \ / \
1 4 9 11
/
3
Así es como, se puede construir un árbol, y finalmente encontrar su recorrido después de la orden, que es: 1, 3, 4, 2, 9, 11, 10, 7, 6