Als de pre-order traversal van een binaire zoekboom is 6, 2, 1, 4, 3, 7, 10, 9, 11, hoe de post-order traversal te krijgen?
Pre-order naar post-order traversal
stemmen
14
11 antwoorden
stemmen 8
8
Pre-order = afgeven van de waarden van een binaire boom in de volgorde van de huidige knoop, dan de linker deelboom, dan de rechter deelboom.
Post-order = afgeven van de waarden van een binaire boom in de volgorde van links substructuur dan de rechter deelboom, de actuele node.
In een binaire zoektocht structuur, de waarden van alle knooppunten in het linker deelboom kleiner zijn dan de waarde van het huidige knooppunt; en gelijk voor de rechter deelboom. Dus als je het begin van een pre-order dump van een binaire zoekboom weten (dwz waarde wordt het knooppunt's) kunt u gemakkelijk ontleden de gehele dump in de wortel knooppunt waarde, de waarden van de knooppunten van het linker deelboom's, en de waarden van knooppunten van de rechter deelboom's.
Voor de uitvoer van de boom in post-order, terugkeer en output herordening wordt toegepast. Deze taak wordt overgelaten aan de lezer.
stemmen 23
23
U krijgt de pre-order traversal van de boom, die is opgebouwd door te doen: output, traverse links doorkruisen rechts.
Omdat de post-order traversal komt uit een BST, kunt u de in-order traversal afleiden (doorkruisen links, output, traverse rechts) uit de post-order traversal door het sorteren van de nummers. In het voorbeeld, het in orde traversal is 1, 2, 3, 4, 6, 7, 9, 10, 11.
Van twee traversals kunnen we dan de oorspronkelijke boom te construeren. Laten we gebruik maken van een eenvoudiger voorbeeld van deze:
- Pre-order: 2, 1, 4, 3
- Involgorde: 1, 2, 3, 4
De pre-order traversal geeft ons de wortel van de boom 2. involgorde traversal zegt 1 valt in de linker subboom en 3, 4 valt in de rechter subboom. De structuur van de linker subboom is triviaal aangezien slechts één element bevat. De juiste sub-boom pre-order traversal wordt afgeleid door het nemen van de volgorde van de elementen in deze sub-boom uit de oorspronkelijke pre-order traversal: 4, 3. Hieruit weten we dat de wortel van de juiste sub-boom is 4 en van de in-order traversal (3, 4) weten we dat 3 valt in de linker sub-boom. Onze laatste boom ziet er als volgt uit:
2
/ \
1 4
/
3
Met de boomstructuur, kunnen we de post-order traversal krijgen door de boom te lopen: traverse naar links, doorkruisen rechts, output. Voor dit voorbeeld, de post-orde traversal 1, 3, 4, 2.
Om het algoritme te generaliseren:
- Het eerste element in de pre-order traversal is de wortel van de boom. Elementen minder dan de basis vormen de linker sub-boom. Elementen die groter is dan de basis vormen van de juiste sub-boom.
- Vind de structuur van de linker en rechter sub-bomen met behulp van stap 1 met een pre-order traversal, dat bestaat uit de elementen die we uitgewerkt om in die sub-boom geplaatst in de volgorde waarin ze in de oorspronkelijke pre-order traversal.
- de resulterende boom doorkruisen in post-order naar de post-order traversal in verband met de gegeven pre-order traversal te krijgen.
Onder toepassing van bovenstaande algoritme post-order traversal geassocieerd met de pre-order traversal in de vraag: 1, 3, 4, 2, 9, 11, 10, 7, 6 daarheen wordt als oefening.
stemmen 3
3
Op basis van antwoord Ondrej Tucny's. Geldig voor BST alleen
voorbeeld:
20
/ \
10 30
/\ \
6 15 35
Preorder = 20 10 6 15 30 35
bericht = 6 15 10 35 30 20
Een BST In Preorder traversal; eerste element van de array 20. Dit is de basis van onze structuur. Alle getallen in matrix waarin minder dan 20 zijn vormen de linker deelboom en grotere aantallen vormen rechter deelboom.
//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;
}
Corrigeer me als er een fout.
stemmen 2
2
krijgt u de pre-order traversal resultaten. zet dan de waarden om een geschikte binaire zoekboom en volg de post-order traversal algoritme voor de verkregen BST.
stemmen 0
0
Ik weet dat dit is oud, maar er is een betere oplossing.
We hoeven niet naar een BST te reconstrueren aan de post-order van de pre-order te krijgen.
Hier is een eenvoudige Python code dat het recursief doet:
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))
Output:
[6, 15, 10, 35, 30, 20]
toelichting :
We weten dat we in de pre-order. Dit betekent dat de wortel aan de index 0van de lijst van de waarden in de BST. En we weten dat de elementen na de wortel zijn:
- eerste: de elementen kleiner is dan de
root, die tot de linker deelboom van de wortel - tweede: de elementen groter is dan de
root, die tot de rechter deelboom van de wortel
Vervolgens hebben we gewoon bellen recursief de functie aan beide substructuren (die nog steeds in de pre-order) en vervolgens keten left + right + root(dat is de post-order).
stemmen 0
0
Als u hebt gekregen preorder en je wilt om te zetten in postorder. Dan moet je niet vergeten dat in een BST om altijd getallen in oplopende geven order.Thus u zowel Inorder evenals de preorder aan een boom te bouwen.
voorafgaande bestelling: 6, 2, 1, 4, 3, 7, 10, 9, 11
in volgorde: 1, 2, 3, 4, 6, 7, 9, 10, 11
En zijn postorder: 1 3 4 2 9 11 10 7 6
stemmen 0
0
Hier pre-order traversal van een binaire zoekboom wordt gegeven in array. Zodat het element 1 van pre-order array wortel van BST.We zal het linkerdeel van BST en rechtergedeelte van BST.All vindt het element pre-order array minder dan root gelaten knooppunt en alle element in pre -order array groter is dan wortel juiste knooppunt is.
#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;
}
stemmen 0
0
Zoals we weten preorder volgen ouder, links, rechts-serie.
Om de boom te bouwen moeten we enkele fundamentele stappen- te volgen:
uw vraag bestaan van de serie 6, 2,1,4,3,7,10,9,11
punten-:
- Eerst aantal series wordt root (bovenliggende) ie 6
2.Find het getal dat groter is dan 6, zodat in deze reeks 7 eerst groter aantal in deze serie zo goed knooppunt wordt vanaf hier en men liet dit aantal (7) is linker substructuren.
6
/ \
2 7
/ \ \
1 4 10
/ / \
3 9 11
3.Same manier volg de basisregel van BST dwz links, wortel, rechts
de reeks postorder zal L, R, N ie 1,3,4,2,9,11,10,7,6
stemmen 0
0
Dit is de code van preorder te traversal postorder in python. Ik ben het bouwen van een boom zodat je elk type traversal kunt vinden
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)
stemmen 0
0
Hier is de volledige code)
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())
stemmen 0
0
Aangezien het een binaire zoekboom, zal de inorder traversal altijd zijn de gesorteerde elementen. (Linker <root <rechts)
ja, kunt u gemakkelijk te schrijven zijn in orde traversal resultaten eerst, dat is: 1,2,3,4,6,7,9,10,11
gegeven Pre-order: 6, 2, 1, 4, 3, 7, 10, 9, 11
In-order: links, wortel, rechts Pre-order: wortel, links, rechts Post-volgorde: links, rechts, wortel
Nu, we door de pre-order, die wortel is 6.
Nu, het gebruiken in orde en pre-order results: Stap 1:
6
/ \
/ \
/ \
/ \
{1,2,3,4} {7,9,10,11}
Stap 2: volgende wortel, het gebruiken in orde traversal, 2:
6
/ \
/ \
/ \
/ \
2 {7,9,10,11}
/ \
/ \
/ \
1 {3,4}
Stap 3: Op dezelfde volgende wortel 4:
6
/ \
/ \
/ \
/ \
2 {7,9,10,11}
/ \
/ \
/ \
1 4
/
3
Stap 4: volgende wortel is 3, doch geen ander element is nog fit in het kind boom voor "3" te zijn. De tweede plaats de wortel als 7 nu,
6
/ \
/ \
/ \
/ \
2 7
/ \ \
/ \ {9,10,11}
/ \
1 4
/
3
Stap 5: Volgende wortel 10:
6
/ \
/ \
/ \
/ \
2 7
/ \ \
/ \ 10
/ \ / \
1 4 9 11
/
3
Zo, een boom kan construeren en eindelijk zijn post-volgorde doorlopen, te weten: 1, 3, 4, 2, 9, 11, 10, 7, 6