Se l'attraversamento di pre-ordine di un albero binario di ricerca è di 6, 2, 1, 4, 3, 7, 10, 9, 11, come ottenere l'attraversamento post-ordine?
Pre-fine di post-ordine di attraversamento
voti
14
11 risposte
voti 8
8
Pre-order = uscita i valori di un albero binario nell'ordine del nodo corrente, allora il sottoalbero sinistro, quindi sottoalbero destro.
Post-ordine = uscita i valori di un albero binario nell'ordine del sottoalbero sinistro, quindi sottoalbero destro, il nodo corrente.
In un binario ricerca albero, i valori di tutti i nodi del sottoalbero sinistro sono inferiori al valore del nodo corrente; e simili per il sottoalbero destro. Quindi se si conosce l'inizio di una discarica pre-ordine di un albero binario di ricerca (cioè il valore del suo nodo radice), si può facilmente scomporre l'intera discarica nel valore nodo principale, i valori dei nodi del sottoalbero di sinistra, ei valori di i nodi del sottoalbero destro.
Per l'uscita l'albero in post-ordine, viene applicata la ricorsione e riordino di uscita. Questo compito è lasciato al lettore.
voti 23
23
Si è data l'attraversamento preordine dell'albero, che è costruito facendo: uscita, traversa a sinistra, attraversare a destra.
Come l'attraversamento post-ordine viene da un BST, si può dedurre l'attraversamento in ordine (Traverse sinistra, uscita, traversa a destra) dal attraversamento post-fine di classificare i numeri. Nel tuo esempio, l'attraversamento in ordine è 1, 2, 3, 4, 6, 7, 9, 10, 11.
Da due attraversamenti possiamo allora costruire l'albero originale. Usiamo un esempio più semplice per questo:
- Pre-order: 2, 1, 4, 3
- In ordine: 1, 2, 3, 4
L'attraversamento pre-ordine ci dà la radice dell'albero come 2. La in ordine di attraversamento ci dice 1 cade nel sottoalbero sinistro e 3, 4 cade nella giusta sub-tree. La struttura del fianco sottoalbero è banale in quanto contiene un unico elemento. traversal pre-ordine del sotto-albero diritto è dedotto prendendo l'ordine degli elementi in questa sotto-albero dall'originale attraversamento pre-ordine: 4, 3. Da questo conosciamo la radice del diritto sub-albero è 4 e dal attraversamento in ordine (3, 4) sappiamo che 3 cade nel sottoalbero sinistro. Il nostro albero finale assomiglia a questo:
2
/ \
1 4
/
3
Con la struttura ad albero, possiamo ottenere l'attraversamento post-ordine a piedi l'albero: traversata a sinistra, attraversare a destra, uscita. Per questo esempio, l'attraversamento post-ordine è 1, 3, 4, 2.
Per generalizzare l'algoritmo:
- Il primo elemento del attraversamento pre-ordine è la radice dell'albero. Elemento raggiunga la radice formano il sottoalbero partita. Elementi superiore alla radice formano destra sottoalbero.
- Trovare la struttura dei sottoalberi sinistro e destro usando passaggio 1 con un attraversamento pre-ordine che consiste degli elementi che ha funzionato per essere in quel sottoalbero disposte nell'ordine in cui appaiono nella attraversamento pre-ordine originale.
- Attraversare l'albero con conseguente post-fine di ottenere l'attraversamento post-ordine associata con il dato attraversamento pre-ordine.
Utilizzando l'algoritmo sopra, l'attraversamento post-ordine associato con l'attraversamento pre-ordine in questione è: 1, 3, 4, 2, 9, 11, 10, 7, 6. Come si è lasciata come esercizio.
voti 3
3
Sulla base di risposta di Ondrej Tucny. Valido per BST solo
esempio:
20
/ \
10 30
/\ \
6 15 35
Preorder = 20 10 6 15 30 35
Post = 6 15 10 35 30 20
Per un BST, In Preorder attraversamento; primo elemento dell'array è 20. Questa è la radice del nostro albero. Tutti i numeri di serie, che sono meno di 20 formano suo sottoalbero sinistro e maggiori numeri costituiscono sottoalbero destro.
//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;
}
Si prega di correggere se c'è qualche errore.
voti 2
2
si è data i risultati attraversamento pre-order. poi mettere i valori ad un idoneo albero binario di ricerca e basta seguire l'algoritmo di attraversamento post-ordine per il BST ottenuto.
voti 0
0
So che questo è vecchio, ma c'è una soluzione migliore.
Non abbiamo di ricostruire un BST per ottenere il post-ordine dal pre-ordine.
Ecco un codice python semplice che lo fa in modo ricorsivo:
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))
Produzione:
[6, 15, 10, 35, 30, 20]
spiegazione :
Sappiamo che siamo in pre-ordine. Ciò significa che la radice è in corrispondenza dell'indice 0dell'elenco dei valori della BST. E sappiamo che gli elementi seguenti radice sono:
- primo: gli elementi inferiori al
root, che appartengono al sottoalbero sinistro della radice - seconda: gli elementi superiore al
root, che appartengono al sottoalbero destro della radice
Abbiamo poi basta chiamare ricorsivamente la funzione su entrambi i sottoalberi (che sono ancora in pre-ordine) e quindi la catena left + right + root(che è il post-ordine).
voti 0
0
Se ti è stato dato preorder e si desidera convertire in postorder. Poi si dovrebbe ricordare che in un BST in modo sempre dare i numeri in ordine crescente order.Thus avete sia Inorder così come il preordine per costruire un albero.
preordinare: 6, 2, 1, 4, 3, 7, 10, 9, 11
In ordine: 1, 2, 3, 4, 6, 7, 9, 10, 11
E il suo postorder: 1 3 4 2 9 11 10 7 6
voti 0
0
Qui pre-ordine di attraversamento di un albero binario di ricerca è dato in array. Così il primo elemento della matrice pre-ordine sarà radice di BST.We troverà la parte sinistra della BST e parte destra BST.All l'elemento in ordine di pre-ordine è minore rispetto radice sarà lasciato nodo e tutto l'elemento in fase di pre order matrice è maggiore di radice sarà nodo destra.
#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;
}
voti 0
0
Come sappiamo preordine seguire genitore, sinistra, destra serie.
Per costruire l'albero abbiamo bisogno di seguire alcuni steps- base:
la tua domanda consistere di serie 6, 2,1,4,3,7,10,9,11
punti-:
- Primo numero di serie sarà radice (genitore) cioè 6
2.Find il numero che è maggiore di 6 così in questa serie 7 è il primo numero maggiore di questa serie nodo in modo giusto sarà a partire da qui e lasciato a questo numero (7) è tuoi sottoalberi sinistro.
6
/ \
2 7
/ \ \
1 4 10
/ / \
3 9 11
modo 3.same seguire la regola di base di BST cioè a sinistra, radicale, destra
la serie di ordine post sarà L, R, N cioè 1,3,4,2,9,11,10,7,6
voti 0
0
Questo è il codice di preordine per postorder attraversamento in python. Sto costruendo un albero in modo da poter trovare qualsiasi tipo di attraversamento
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)
voti 0
0
Ecco il codice 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())
voti 0
0
Dal momento che, si tratta di un albero binario di ricerca, l'attraversamento in ordine simmetrico sarà sempre gli elementi ordinati. (Sinistra <root <a destra)
così, si può facilmente scrivere i suoi risultati attraversamento in ordine prima, che è: 1,2,3,4,6,7,9,10,11
in Pre-ordine: 6, 2, 1, 4, 3, 7, 10, 9, 11
In ordine: sinistra, radice, proprio Pre-order: root, sinistra, destra post-ordine: sinistra, destra, radice
ora, abbiamo ottenuto da pre-ordine, quella radice è 6.
Ora, utilizzando in ordine e risultati pre-ordine: Fase 1:
6
/ \
/ \
/ \
/ \
{1,2,3,4} {7,9,10,11}
Fase 2: la prossima radice è, utilizzando in-ordine di attraversamento, 2:
6
/ \
/ \
/ \
/ \
2 {7,9,10,11}
/ \
/ \
/ \
1 {3,4}
Fase 3: Analogamente, prossima radice è 4:
6
/ \
/ \
/ \
/ \
2 {7,9,10,11}
/ \
/ \
/ \
1 4
/
3
Fase 4: la prossima radice è 3, ma nessun altro elemento è rimanenti per essere in forma nella struttura di bambino per "3". Considerando prossima radice 7 ora,
6
/ \
/ \
/ \
/ \
2 7
/ \ \
/ \ {9,10,11}
/ \
1 4
/
3
Fase 5: root successivo è 10:
6
/ \
/ \
/ \
/ \
2 7
/ \ \
/ \ 10
/ \ / \
1 4 9 11
/
3
In questo modo, è possibile costruire un albero, e, infine, trovare il suo attraversamento post-ordine, che è: 1, 3, 4, 2, 9, 11, 10, 7, 6