Wenn die vorbestellbarer Traversal eines binären Suchbaum 6, 2, 1, 4, 3, 7, 10, 9, 11, wie die Post-Order-Traversal erhalten?
Vorbestellen zu Post-Order-Traversal
stimmen
14
11 antworten
stimmen 8
8
Vorbestellbarer = die Werte eines binären Baums in der Reihenfolge des aktuellen Knotens ausgegeben wird , dann wird der linke Unterbaum, dann den rechten Unterbaum.
Post-Order = die Werte eines binären Baums in der Reihenfolge des linken Unterbaum ausgibt, dann den rechten Teilbaum, der der aktuelle Knoten.
In einem binären Suchbaum sind die Werte aller Knoten in dem linken Teilbaum kleiner als der Wert des aktuellen Knotens; und gleichermaßen für den rechten Unterbaum. Wenn Sie also den Beginn einer Pre-Order - Dump eines binären Suchbaum (dh dessen Wurzelknoten Wert) kennen, können Sie bequem die ganze Dump in den Wurzelknotenwert zersetzen, werden die Werte des linken Teilbaumes der Knoten, und die Werte von rechten Teilbaum der Knoten.
Zur Ausgabe wird der Baum in Post-Order, Rekursion und Ausgang Umordnung angewandt. Diese Aufgabe wird bei dem Leser überlassen.
stimmen 23
23
Sie sind die Pre-Order-Traversal des Baumes gegeben, die durch Tun aufgebaut ist: Ausgang, Traverse links, überqueren rechts.
Da der Post-Order Traversal von einem BST kommt, können Sie das in Ordnung Traversal (Traverse links, Ausgang, Traverse rechts) von der Post-Order Traversal ableiten durch die Zahlen zu sortieren. In Ihrem Beispiel ist die in Ordnung traversal 1, 2, 3, 4, 6, 7, 9, 10, 11.
Von zwei Überquerungen können wir dann den ursprünglichen Baum konstruieren. Lassen Sie uns ein einfacheres Beispiel für diesen Einsatz:
- Vorbestellbarer: 2, 1, 4, 3
- In-Reihenfolge: 1, 2, 3, 4
Die Pre-Order Traversal gibt uns die Wurzel des Baumes als 2. Die in Ordnung Traversal sagt uns, 1 fällt in den linken Unterbaum und 3, 4 fällt in den rechten Unterbaum. Die Struktur des linken Unterbaum ist trivial, da es ein einzelnes Element enthält. Der rechte Teilbaum der Pre-Order-Traversal wird berechnet, indem die Reihenfolge der Elemente in diesem Unterbaum von der ursprünglichen Pre-Order Traversal abgeleitet: 4, 3. Daran erkennen wir, die Wurzel des rechten Unterbaum 4 und aus dem in-order-Traversal (3, 4) wir wissen, dass 3 den linken Unterbaum fällt. Unsere letzte Baum sieht wie folgt aus:
2
/ \
1 4
/
3
Mit der Baumstruktur können wir die Post-Order Traversal erhalten, indem Sie den Baum zu Fuß: Traverse nach links, überqueren rechts ausgegeben. Für dieses Beispiel ist die Post-Order-Traversal-1, 3, 4, 2.
Zu verallgemeinern den Algorithmus:
- Das erste Element in der vorbestellbarer Traversierung ist die Wurzel des Baums. Elemente kleiner als die Grundform des linken Unterbaumes. Elemente größer ist als die Grundform der rechten Unterbaum.
- Finden Sie die Struktur der linken und rechten Teilbäume unter Verwendung von Schritt 1 mit einer Pre-Order Traversal, die wir gearbeitet der Elemente besteht aus in diesem Teilbaum in der Reihenfolge, wie sie in der ursprünglichen Pre-Order Traversal erscheinen platziert sein.
- Fahren Sie den resultierenden Baum in der Post um die Post-Order Traversal mit der angegebenen Pre-Order Traversal verbunden zu bekommen.
Unter Verwendung des obigen Algorithmus, der Post-Order-Traversal mit der vorbestellbarer Traversal in der Frage zugeordnet ist: 1, 3, 4, 2, 9, 11, 10, 7, 6 AN- wird als Übung.
stimmen 3
3
Basierend auf Ondrej Tučný Antwort. Gültig für BST nur
Beispiel:
20
/ \
10 30
/\ \
6 15 35
Preorder = 20 10 6 15 30 35
post = 6 15 10 35 30 20
Für ein BST, In Vorordnungsdurchquerung; das erste Element des Arrays ist 20. Dies ist die Wurzel des Baumes ist unser. Alle Zahlen in der Matrix, die weniger sind als 20 seinen linker Unterbaum bilden und größere Zahlen bilden rechten Teilbaum.
//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;
}
Bitte korrigieren Sie mich, wenn es einen Fehler.
stimmen 2
2
Sie sind die Pre-Order-Traversal-Ergebnisse. setzen Sie dann die Werte auf einen geeigneten binären Suchbaum und folgen Sie einfach dem Post-Order-Traversal-Algorithmus für die erhaltene BST.
stimmen 0
0
Ich weiß, das ist alt, aber es gibt eine bessere Lösung.
Wir haben keine BST zu rekonstruieren, die Post-Order aus der Pre-Order zu bekommen.
Hier ist ein einfacher Python-Code, der es rekursiv tut:
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))
Ausgabe:
[6, 15, 10, 35, 30, 20]
Erläuterung :
Wir wissen , dass wir in Vorbestellung sind. Dies bedeutet , dass die Wurzel in dem Index ist 0in der Liste der Werte in dem BST. Und wir wissen , dass die Elemente , die die Wurzel folgenden sind:
- Erstens: Die Elemente weniger als die
root, welche zu der linken Unterbaum des Wurzel - Zweitens: die Elemente größer ist als die
root, welche zu dem rechten Unterbaum des Wurzel
Wir rufen Sie dann nur rekursiv die Funktion auf beiden Teilstrukturen (die in Pre-Order sind) und dann Kette left + right + root(das ist die Post-Order).
stimmen 0
0
Wenn Sie wurden Preorder gegeben und Sie wollen es in Postorder konvertieren. Dann sollten Sie, dass in einem BST, um immer geben Zahlen in aufsteigender erinnern order.Thus Sie haben beide Inorder sowie die Preorder einen Baum zu konstruieren.
Vorbestellung: 6, 2, 1, 4, 3, 7, 10, 9, 11
in Ordnung: 1, 2, 3, 4, 6, 7, 9, 10, 11
Und seine Postorder: 1 3 4 2 9 11 10 7 6
stimmen 0
0
Hier vorbestellen Traversal eines binären Suchbaum wird in Array. Also das erste Element des Pre-Order-Array wird von BST.We Wurzel wird den linken Teil von BST und rechtsem Teil des BST.All findet das Element in vorbestellen Array ist kleiner als Wurzelknoten gelassen werden und alle das Element in pre -Auftrag Array ist größer als root rechten Knoten sein.
#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;
}
stimmen 0
0
Wie wir wissen Preorder Eltern, links, rechts Serie folgen.
Um Baum zu konstruieren, müssen wir einige grundlegende Schritten- folgen:
besteht Ihre Frage der Serie 6, 2,1,4,3,7,10,9,11
Punkte-:
- Erste Anzahl von in Reihe wird root (parent) dh 6
2.Suchen die Zahl, die größer als 6 so in dieser Serie 7 ist die erste größere Anzahl in dieser Serie so richtig Knoten wird von hier und von links nach dieser Nummer beginnen (7) sind die linken Teilbäume.
6
/ \
2 7
/ \ \
1 4 10
/ / \
3 9 11
3.same Weg, um die Grundregel von BST dh links, Wurzel folgen, rechts
die Reihe von Postauftrag wird L, R, N, dh seine 1,3,4,2,9,11,10,7,6
stimmen 0
0
Dies ist der Code von Vorordnungsdurchquerung in Python Postorder. Ich konstruiere einen Baum, so dass Sie jede Art von Traversal finden
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)
stimmen 0
0
Hier ist voll 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())
stimmen 0
0
Da es sich um eine binäre Suchbaum ist, wird die Inorder Traversal immer die sortierten Elemente sein werden. (Links <root <rechts)
so kann man leicht seine in Ordnung Traversal Ergebnisse schreibt zuerst, das ist: 1,2,3,4,6,7,9,10,11
Pre-Befehl gegeben: 6, 2, 1, 4, 3, 7, 10, 9, 11
In Ordnung: links, Wurzel, rechts Vorbestellen: root, links, rechts nach der Bestellung: links, rechts, Wurzel
jetzt, wir haben aus vorbestellen, ist, dass root 6.
jetzt, mit in Ordnung und jetzt vorbestellen Ergebnisse: Schritt 1:
6
/ \
/ \
/ \
/ \
{1,2,3,4} {7,9,10,11}
Schritt 2: Die nächste Wurzel ist, in Ordnung traversal Verwendung 2:
6
/ \
/ \
/ \
/ \
2 {7,9,10,11}
/ \
/ \
/ \
1 {3,4}
Schritt 3: In ähnlicher Weise ist nächste Wurzel 4:
6
/ \
/ \
/ \
/ \
2 {7,9,10,11}
/ \
/ \
/ \
1 4
/
3
Schritt 4: nächste Wurzel 3, aber kein anderes Element übrig ist für „3“ fit in dem Kind Baum zu sein. nächste Wurzel als 7 Betrachtet man nun,
6
/ \
/ \
/ \
/ \
2 7
/ \ \
/ \ {9,10,11}
/ \
1 4
/
3
Schritt 5: Die nächste Wurzel 10:
6
/ \
/ \
/ \
/ \
2 7
/ \ \
/ \ 10
/ \ / \
1 4 9 11
/
3
Dies ist, wie man einen Baum bauen kann, und schließlich seine Post-Order Traversal finden, das ist: 1, 3, 4, 2, 9, 11, 10, 7, 6