În cazul în care traversal pre-comanda unui arbore binar de căutare este de 6, 2, 1, 4, 3, 7, 10, 9, 11, cum să obțineți traversal post-comandă?
Pre-comanda post-comandă parcurgeri
voturi
14
11 răspunsuri
voturi 8
8
Pre-comanda = plotare valorile unui arbore binar în ordinea nodului curent, apoi subarborele stâng, apoi subarborele din dreapta.
Post-comandă = plotare valorile unui arbore binar în ordinea subarborelui stâng, apoi subarborele drept, nodul curent.
Într - un binar de căutare copac, valorile tuturor nodurilor din subarborele stâng sunt mai mici decât valoarea nodului curent; și deopotrivă pentru subarborelui drept. Prin urmare , dacă știți începutul unui depozit de pre-comanda unui arbore binar de căutare ( de exemplu , valoarea nodul root), puteți descompune cu ușurință întreaga groapa în valoarea nodului rădăcină, valorile nodurilor subarborele stâng, și valorile nodurile subarborele din dreapta lui.
Pentru a scoate arborele în post-comandă, se aplică recursie și reordonare de ieșire. Această sarcină este lăsată asupra cititorului.
voturi 23
23
Vi se dat traversal pre-comanda a arborelui, care este construit de a face: iesire, stanga traversa, traversa dreapta.
Deoarece traversal post-comanda vine de la un BST, puteți deduce în ordine traversal (Traverse din stânga, de ieșire, deplasare dreapta) de la traversal post-comanda prin sortarea numerelor. În exemplul dumneavoastră, în traversare ordine este 1, 2, 3, 4, 6, 7, 9, 10, 11.
Din două traversări putem construi apoi arborele original. Să folosim un exemplu mai simplu pentru acest lucru:
- Pre-comanda: 2, 1, 4, 3
- În ordine: 1, 2, 3, 4
Precomanda traversal ne dă rădăcina copacului ca 2. în ordine parcurgeri ne spune 1 se încadrează în sub-arborele din stânga și 3, 4 se încadrează în sub-copac dreapta. Structura sub-arborele stâng este trivială deoarece conține un singur element. Traversarea precomanda dreapta sub-arborelui este dedus prin luarea ordinea elementelor din această sub-copac din original traversal precomandă: 4, 3. Din aceasta cunoaștem rădăcina sub-copac dreapta este 4 și din traversal în ordine (3, 4) știm că 3 intră în sub-arborele din stânga. copac nostru final arată astfel:
2
/ \
1 4
/
3
Cu structura de copac, putem obține traversal post-comanda de mers pe jos de copac: traversare la stânga, dreapta traversează, de ieșire. Pentru acest exemplu, traversal post-comandă este 1, 3, 4, 2.
Pentru a generaliza algoritmul:
- Primul element din traversal precomanda este rădăcina copacului. Elementele mai puțin decât rădăcina formează sub-arborele din stânga. Elemente mai mari decât rădăcina formează sub-copac dreapta.
- Găsiți structura sub-arborii din stânga și din dreapta, folosind pasul 1 cu o traversal precomandă, care constă din elementele pe care am lucrat a fi în acel sub-arbore plasat în ordinea în care apar în original traversal precomandă.
- Traverse copac care rezultă în post-pentru a obține traversal post-comandă asociată cu date traversal precomandă.
Folosind algoritmul de mai sus, traversal post-comandă asociată cu traversal precomandă în întrebarea este: 1, 3, 4, 2, 9, 11, 10, 7, 6. Cum se rămâne ca exercițiu.
voturi 3
3
Pe baza răspunsului Ondrej Tucny lui. Valabil pentru BST numai de
exemplu:
20
/ \
10 30
/\ \
6 15 35
Precomanda = 10 6 15 20 30 35
Mesaj = 10 35 6 15 30 20
Pentru o BST, în parcurgeri Precomandați; primul element de matrice este de 20. Aceasta este rădăcina arborelui nostru. Toate numerele din matrice, care sunt mai mici decât 20 forma subarborele sau la stânga și la un număr mai mare forma de subramificație dreapta.
//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;
}
Vă rugăm să corectați-mă dacă există vreo greșeală.
voturi 2
2
vi se precomanda rezultatele traversal. apoi pune valorile unui arbore binar de căutare adecvat și trebuie doar să urmezi algoritmul traversal post pentru BST obținut.
voturi 0
0
Știu că acest lucru este vechi, dar există o soluție mai bună.
Noi nu trebuie să reconstruiască o BST pentru a obține post-comanda de la pre-comanda.
Aici este un cod de piton simplu care face recursiv:
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))
ieşire:
[6, 15, 10, 35, 30, 20]
explicaţie :
Știm că suntem în precomandă. Acest lucru înseamnă că rădăcina este la indexul 0listei valorilor din BST. Și noi știm că elementele următoare rădăcină sunt:
- în primul rând: elementele de mai puțin decât
root, care aparțin subarborele stâng al rădăcinii - în al doilea rând: elementele mai mari decât
root, care aparțin subarborelui drept al rădăcinii
Noi apoi apel doar recursiv funcția pe ambele subarbori (care încă mai sunt în precomandă) și apoi lanțul left + right + root(care este post-comanda).
voturi 0
0
Dacă vi sa dat precomandă și doriți să-l transforme în postordine. Atunci ar trebui să ne amintim că într-un BST, pentru a da întotdeauna numere în crescător order.Thus aveți atât Inorder cât și precomanda pentru a construi un copac.
pre-comanda: 6, 2, 1, 4, 3, 7, 10, 9, 11
pentru a: 1, 2, 3, 4, 6, 7, 9, 10, 11
Și postordine sale: 1 3 4 2 9 11 10 7 6
voturi 0
0
Aici traversal pre-comanda unui arbore binar de căutare este dat în matrice. Deci, primul element al precomandă matrice va rădăcină de BST.We va găsi partea din stânga a BST și partea din dreapta a BST.All elementului în pre-comanda matrice este mai mică decât rădăcină va fi lăsat nod și toate elementul în pre matrice -Ordinul este mai mare, atunci rădăcină va fi nodul dreapta.
#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;
}
voturi 0
0
După cum știm precomanda a urmări părinte, stânga, dreapta serie.
În scopul de a construi copac trebuie să urmeze câteva steps- de bază:
întrebarea dvs. constau din seria 6, 2,1,4,3,7,10,9,11
Puncte tari:
- Primul număr de serie va fi rădăcină (părinte), adică 6
2.Find numărul care este mai mare de 6 astfel încât în această serie 7 este primul număr mai mare în această serie, astfel nod dreapta va fi incepand de aici și la stânga la acest număr (7) este subarbori stâng.
6
/ \
2 7
/ \ \
1 4 10
/ / \
3 9 11
mod 3.same urmează regula de bază de exemplu BST din stânga, rădăcină, dreapta
seria de ordine post va fi L, R, N adică 1,3,4,2,9,11,10,7,6
voturi 0
0
Acesta este codul de precomandă la postordine traversal în Python. Sunt construirea unui copac, astfel încât să puteți găsi orice tip de parcurgeri
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)
voturi 0
0
Aici este codul 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())
voturi 0
0
Deoarece, acesta este un arbore de căutare binară, traversal inordine va fi întotdeauna fi elementele sortate. (Stânga <rădăcină <dreapta)
astfel încât, puteți scrie cu ușurință în ordine rezultatele sale traversal în primul rând, care este: 1,2,3,4,6,7,9,10,11
dat Precomandă: 6, 2, 1, 4, 3, 7, 10, 9, 11
În ordine: stânga, rădăcină, dreapta pre-comanda: rădăcină, stânga, dreapta post-comandă: stânga, dreapta, rădăcină
acum, am primit de la pre-comanda, care radacina este 6.
acum, folosind în ordine și rezultatele precomandă: Etapa 1:
6
/ \
/ \
/ \
/ \
{1,2,3,4} {7,9,10,11}
Pasul 2: rădăcină următor este, folosind parcurgeri în ordine, 2:
6
/ \
/ \
/ \
/ \
2 {7,9,10,11}
/ \
/ \
/ \
1 {3,4}
Etapa 3: In mod similar, rădăcină următor este 4:
6
/ \
/ \
/ \
/ \
2 {7,9,10,11}
/ \
/ \
/ \
1 4
/
3
Pasul 4: rădăcină următor este 3, dar nici un alt element este rămas să fie apt în arborele copil „3“. Având în vedere rădăcină următoare, ca 7 acum,
6
/ \
/ \
/ \
/ \
2 7
/ \ \
/ \ {9,10,11}
/ \
1 4
/
3
Pasul 5: rădăcină Următorul este 10:
6
/ \
/ \
/ \
/ \
2 7
/ \ \
/ \ 10
/ \ / \
1 4 9 11
/
3
Acesta este modul în care, puteți construi un copac, și în cele din urmă găsi traversal post-comandă, care este: 1, 3, 4, 2, 9, 11, 10, 7, 6