Forhåndsbestill til post-order traversering

Forhånds orden = utmating av verdiene av et binært tre i størrelsesorden av den aktuelle node, så venstre treet, så den høyre subtre.

Post-order = gi ut verdiene av et binært tre i rekkefølgen av venstre treet, deretter høyre treet, den gjeldende node.

I et binært søk tre, verdiene av alle nodene i det venstre subtre er mindre enn verdien av den aktuelle noden; og like etter den rette treet. Derfor hvis du vet starten på en pre-order dump av et binært søketre (dvs. rotnoden verdi), kan du enkelt dekomponere hele dump i rotnoden verdi, verdiene av venstre undertreet noder, og verdiene av høyre undertreet noder.

For å sende ut treet i post-rekkefølge, blir rekursjon og utgang omordning anvendt. Denne oppgaven blir igjen på leseren.

Basert på Ondrej Tucny svar. Gyldig for BST eneste
eksempel:

     20  
    /  \  
   10  30  
   /\    \  
  6  15   35  

Preorder = 20 10 6 15 30 35
Post = 6 15 10 35 30 20

For en BST, In forhåndsbestilling traversering; første element i matrisen er 20. Dette er roten av treet vårt. Alle tall i matrisen som er mindre enn 20 danner dens venstre subtre og større tall danner rett subtre.

//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;
 }

Rett meg hvis det er noen feil.

du får pre-order traversering resultater. deretter sette verdiene til et egnet binært søketre og bare følge etter for traversering algoritmen for den oppnådde BST.

Jeg vet dette er gammelt, men det er en bedre løsning.

Vi trenger ikke å rekonstruere en BST å få post-ordre fra pre-order.

Her er en enkel python kode som gjør det rekursivt:

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))

Produksjon:

 [6, 15, 10, 35, 30, 20]

Forklaring :

Vi vet at vi er i pre-order. Dette betyr at roten er ved indeks 0av listen over verdiene i BST. Og vi vet at elementene følgende roten er:

• først: elementene mindre enn den root, som tilhører den venstre subtre av roten
• andre: de elementene som er større enn den rootsom hører til den høyre subtre av roten

Vi så bare ring rekursivt funksjonen på begge undertrær (som fortsatt er i pre-order) og deretter kjeden left + right + root(som er den post-rekkefølge).

Hvis du har fått forhåndsbestilling og du ønsker å konvertere den til Postorder. Da bør du huske på at i en BST for alltid gi tall i stigende order.Thus du har både Inorder samt forhåndsbestilling å konstruere et tre.

forhåndsbestille: 6, 2, 1, 4, 3, 7, 10, 9, 11

i rekkefølge: 1, 2, 3, 4, 6, 7, 9, 10, 11

Og dens Postorder: 1 3 4 2 9 11 10 7 6

Her pre-order traversering av et binært søketre er gitt i tabellen. Så første del av pre-order array vil roten av BST.We vil finne den venstre delen av BST og høyre del av BST.All elementet i pre-order rekke er mindre enn roten vil bli liggende node og All elementet i pre -Bestill matrise er større enn roten vil være rett node.

#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;
} 

Som vi vet forhåndsbestilling følge forelder, venstre, høyre-serien.

For å konstruere treet må vi følge noen grunnleggende trinn-:

spørsmålet ditt består av serie 6, 2,1,4,3,7,10,9,11

poeng:

1. Første rekke serier vil være rot (parent), dvs. 6

2.Find antall som er større enn 6 så i denne serien 7 er første større antall i denne serien så rett node vil starte herfra og til venstre til dette nummeret (7) er din venstre subtre.

                      6
                    /   \
                   2     7
                 /  \     \
                1    4     10
                     /     / \
                     3     9  11

3.same måte følger den grunnleggende regelen for BST dvs. venstre, rot, ikke sant

rekken av post orden vil være L, R, N ie 1,3,4,2,9,11,10,7,6

Dette er koden for forhåndsbestilling til Postorder traversering i python. Jeg bygger et tre, slik at du kan finne alle typer traversering

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)

Her er full kode)

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())

Siden det er et binært søketre vil inorder traversering være alltid være de sorterte elementene. (Venstre <rot <høyre)

I så fall kan du enkelt skrive sine i orden traversering resultater først, som er: 1,2,3,4,6,7,9,10,11

gitt Forhånds rekkefølge: 6, 2, 1, 4, 3, 7, 10, 9, 11

In-rekkefølge: venstre, rot, rett Pre-order: root, venstre, høyre Post-rekkefølge: venstre, høyre, rot

nå, vi har fått fra pre-order, er at roten 6.

nå, ved hjelp av i-og for pre-order resultater: Trinn 1:

             6
            / \
           /   \
          /     \
         /       \
   {1,2,3,4}  {7,9,10,11}

Trinn 2: neste roten er, ved hjelp av i-rekkefølge traversering, 2:

             6
            / \
           /   \
          /     \
         /       \
        2  {7,9,10,11}
       / \
      /   \
     /     \
    1    {3,4}

Trinn 3: På lignende måte er ved roten 4:

             6
            / \
           /   \
          /     \
         /       \
        2  {7,9,10,11}
       / \
      /   \
     /     \
    1       4
           /
          3

Trinn 4: neste roten er tre, men ingen andre element som er igjen for å passe på barnet treet for "3". Vurderer neste root som 7 nå,

             6
            / \
           /   \
          /     \
         /       \
        2         7
       / \         \
      /   \       {9,10,11}
     /     \
    1       4
           /
          3

Trinn 5: Neste roten er 10:

             6
            / \
           /   \
          /     \
         /       \
        2         7
       / \         \
      /   \         10
     /     \       /  \
    1       4     9   11
           /
          3

Dette er hvordan du kan konstruere et tre, og til slutt finner sin post-order traversering, som er: 1, 3, 4, 2, 9, 11, 10, 7, 6