Si le traversal pré-commande d'un arbre de recherche binaire est 6, 2, 1, 4, 3, 7, 10, 9, 11, comment obtenir le traversal post-commande?
Pré-commande pour traversal post-commande
voix
14
11 réponses
voix 8
8
Pré-commande = délivrer en sortie les valeurs d'un arbre binaire dans l'ordre du noeud actuel, puis le sous - arbre gauche, puis le sous - arbre droit.
Post-order = délivrer en sortie les valeurs d'un arbre binaire dans l'ordre de la sous - arborescence de gauche, puis le sous - arbre droit, le nœud courant.
Dans un binaire de recherche arbre, les valeurs de tous les nœuds du sous - arbre gauche sont inférieures à la valeur du nœud courant; et aussi bien pour le sous - arbre droit. Par conséquent , si vous connaissez le début d'une décharge pré-commande d'un arbre de recherche binaire (sa valeur du nœud racine), vous pouvez facilement décomposer la décharge entier dans la valeur du nœud racine, les valeurs des nœuds du sous - arbre gauche, et les valeurs de les nœuds du sous - arbre droit.
Pour produire l'arbre en post-ordre, récursivité et réordonnancement de sortie est appliquée. Cette tâche est laissée sur le lecteur.
voix 23
23
Vous avez la traversal pré-commande de l'arbre, qui est construit en faisant: sortie, traverser à gauche, traverser à droite.
Comme le traversal post-commande provient d'un BST, vous pouvez déduire le en ordre traversal (traverse gauche, sortie, traverse à droite) de la traversal post-ordre en triant les numéros. Dans votre exemple, dans le parcours d'ordre est égal à 1, 2, 3, 4, 6, 7, 9, 10, 11.
De deux traversals nous pouvons construire l'arbre d'origine. Utilisons un exemple plus simple pour cela:
- Pré-commande: 2, 1, 4, 3
- Dans l'ordre: 1, 2, 3, 4
Le parcours pré-commande nous donne la racine de l'arbre comme 2. dans l'ordre traversal nous dit 1 tombe dans le sous-arbre gauche et 3, 4 tombe dans le sous-arbre droit. La structure du sous-arbre gauche est triviale car il contient un seul élément. Le parcours pré-commande de sous-arbre droit est déduit en prenant l'ordre des éléments dans ce sous-arbre du traversal pré-commande d'origine: 4, 3. A partir de ce que nous connaissons la racine du sous-arbre droit est 4 et de l'ordre dans traversal (3, 4), nous savons que 3 tombe dans le sous-arbre gauche. Notre arbre final ressemble à ceci:
2
/ \
1 4
/
3
Avec la structure de l'arbre, nous pouvons obtenir le traversal post-ordre en marchant l'arbre: traverser à gauche, traverser à droite, sortie. Pour cet exemple, le parcours de post-commande est 1, 3, 4, 2.
Pour généraliser l'algorithme:
- Le premier élément de la traversal pré-commande est la racine de l'arbre. Les éléments moins que la racine forment le sous-arbre gauche. Les éléments plus que la racine forment le sous-arbre droit.
- Trouver la structure des sous-arbres gauche et à droite à l'aide de l'étape 1 avec un parcours pré-commande qui se compose des éléments que nous ELABOREE être dans ce sous-arbre placé dans l'ordre où ils apparaissent dans le traversal pré-commande d'origine.
- Traverse l'arbre entraînant après afin d'obtenir le traversal post-commande associée à la traversal pré-ordre donné.
En utilisant l'algorithme ci-dessus, la traversée de post-commande associée à la traversée de pré-commande à la question est la suivante: 1, 3, 4, 2, 9, 11, 10, 7, 6. Mise il est laissé en exercice.
voix 3
3
Sur la base de la réponse de Ondrej Tucny. Valable pour BST seulement par
exemple:
20
/ \
10 30
/\ \
6 15 35
Preorder = 20 10 6 15 30 35
post 15 10 = 6 35 30 20
Pour un BST, en Précommande traversal; premier élément de tableau est 20. Ceci est la racine de notre arbre. Tous les nombres en série qui sont moins de 20 forment le sous-arbre gauche et un plus grand nombre forment sous-arbre droit.
//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;
}
S'il vous plaît me corriger s'il y a une erreur.
voix 2
2
vous donne les résultats traversal pré-commande. puis mettre les valeurs à un arbre de recherche binaire approprié et il suffit de suivre l'algorithme de post-ordre traversal pour la BST obtenue.
voix 0
0
Je sais que c'est vieux, mais il y a une meilleure solution.
Nous ne devons pas reconstruire un BST pour obtenir le post-commande de la précommande.
Voici un simple code python qui le fait de manière récursive:
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))
Sortie:
[6, 15, 10, 35, 30, 20]
explication :
Nous savons que nous sommes en pré-commande. Cela signifie que la racine est à l'index 0de la liste des valeurs du BST. Et nous savons que les éléments suivants sont la racine:
- première: les éléments inférieurs à la
root, qui appartiennent à la sous - arborescence de gauche de la racine - secondes: les éléments plus grand que le
root, qui appartiennent à la sous - arbre droit de la racine
Nous alors appeler la fonction récursive sur les deux sous - arbres (qui sont encore en pré-commande) et la chaîne left + right + root(qui est le post-commande).
voix 0
0
Si vous avez été donné pré-commande et que vous voulez convertir en postorder. Ensuite, vous devez vous rappeler que, dans un BST pour donner toujours des nombres dans l'ordre croissant order.Thus vous avez les deux Inorder ainsi que la pré-commande pour construire un arbre.
Pré-commander: 6, 2, 1, 4, 3, 7, 10, 9, 11
en ordre: 1, 2, 3, 4, 6, 7, 9, 10, 11
Et son postorder: 1 3 4 2 9 11 10 7 6
voix 0
0
Ici traversal pré-commande d'un arbre de recherche binaire est donnée dans le tableau. Ainsi, le 1er élément du tableau pré-commande ancrera de BST.We trouvera la partie gauche de la partie BST et à droite de BST.All l'élément dans le tableau de précommande est moindre que root sera laissé noeud et de tout l'élément en pré -order tableau est supérieure à la racine sera nœud droite.
#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;
}
voix 0
0
Comme nous le savons Précommande suivre parents, à gauche, à droite série.
Pour construire l'arbre, nous devons suivre quelques étapes- de base:
votre question se composent de la série 6, 2,1,4,3,7,10,9,11
points-:
- Le premier chiffre de la série sera racine (parent) soit 6
2.Find le nombre est supérieur à 6 donc dans cette série 7 est le premier plus grand nombre dans cette série nœud si bon sera à partir d'ici et à gauche à ce numéro (7) est votre gauche sous-arbres.
6
/ \
2 7
/ \ \
1 4 10
/ / \
3 9 11
3.same façon de suivre la règle de base de BST-à-dire à gauche, racine, droit
la série de l'ordre de poste sera L, R, N ie 1,3,4,2,9,11,10,7,6
voix 0
0
Voici le code de précommande à Postorder traversal en python. Je construis un arbre de sorte que vous pouvez trouver tout type de traversal
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)
voix 0
0
Voici le code complet)
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())
voix 0
0
Depuis, il est un arbre de recherche binaire, le parcours infixe sera toujours être les éléments triés. (Gauche <racine <droite)
, vous pouvez facilement écrire ses produits en ordre des résultats traversal premier, qui est: 1,2,3,4,6,7,9,10,11
donnée pré-commande: 6, 2, 1, 4, 3, 7, 10, 9, 11
En ordre: à gauche, racine, droit Précommandez: racine, gauche, droite post-ordre: gauche, droite, racine
maintenant, nous avons reçu de pré-commande, cette racine est 6.
maintenant, en utilisant dans l'ordre et les résultats pré-commande: Etape 1:
6
/ \
/ \
/ \
/ \
{1,2,3,4} {7,9,10,11}
Étape 2: racine suivante est, en utilisant dans l'ordre traversal, 2:
6
/ \
/ \
/ \
/ \
2 {7,9,10,11}
/ \
/ \
/ \
1 {3,4}
Étape 3: De même, la racine suivante est 4:
6
/ \
/ \
/ \
/ \
2 {7,9,10,11}
/ \
/ \
/ \
1 4
/
3
Étape 4: racine suivante est 3, mais aucun autre élément est restant à être en forme dans l'arbre des enfants pour « 3 ». Compte tenu de la racine suivante comme 7 maintenant,
6
/ \
/ \
/ \
/ \
2 7
/ \ \
/ \ {9,10,11}
/ \
1 4
/
3
Étape 5: racine suivante est 10:
6
/ \
/ \
/ \
/ \
2 7
/ \ \
/ \ 10
/ \ / \
1 4 9 11
/
3
Voici comment, vous pouvez construire un arbre, et enfin trouver son traversal post-ordre, qui est: 1, 3, 4, 2, 9, 11, 10, 7, 6