Προ-παραγγελία για διάσχιση μετά την παραγγελία

Προ-παραγγελία = εξάγοντας τις τιμές ενός δυαδικού δένδρου με τη σειρά του τρέχοντος κόμβου, τότε το αριστερό υποδένδρο, τότε η σωστή υποδένδρο.

Μετά την παραγγελία = έξοδο τις τιμές ενός δυαδικού δέντρου με τη σειρά του αριστερού υποδένδρο, τότε το δικαίωμα υποδέντρο, η ο τρέχων κόμβος.

Σε ένα δυαδικό αναζήτησης δέντρο, οι τιμές όλων των κόμβων στο αριστερό υποδένδρο είναι μικρότερη από την αξία του τρέχοντος κόμβου? και όσο για το δικαίωμα υποδένδρο. Ως εκ τούτου, αν γνωρίζετε την έναρξη μιας χωματερής προ-παραγγελία από ένα δυαδικό δέντρο αναζήτησης (δηλαδή την αξία ρίζα τον κόμβο του είναι), μπορείτε εύκολα να αποσυντεθεί το σύνολο χωματερή στην τιμή κόμβο ρίζας, οι τιμές των κόμβων του αριστερού υποδέντρο του, και οι τιμές των κόμβους του δικαιώματος υποδέντρο του.

Για έξοδο το δέντρο στη θέση τάξης, εφαρμόζεται αναδρομή και αναδιάταξη της παραγωγής. Το έργο αυτό έχει απομείνει από τη συσκευή ανάγνωσης.

Με βάση την απάντηση Ondrej Tucny του. Ισχύει για BST μόνο
παράδειγμα:

     20  
    /  \  
   10  30  
   /\    \  
  6  15   35  

Προπαραγγελία = 20 10 6 15 30 35
Δημοσίευση = 6 15 10 35 30 20

Για μια BST, Σε Προπαραγγελία διάσχιση? πρώτο στοιχείο του πίνακα είναι 20. Αυτό είναι η ρίζα του δέντρου μας. Όλοι οι αριθμοί στην διάταξη που είναι μικρότερο από 20 σχηματίζουν αριστερά υποδένδρο του και μεγαλύτερους αριθμούς σχηματίζουν δεξιά υποδένδρο.

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

Παρακαλώ διορθώστε με αν υπάρχει κάποιο λάθος.

σας δίνεται τα αποτελέσματα διάσχιση προ-παραγγελία. στη συνέχεια, τοποθετήστε τις τιμές σε ένα κατάλληλο δυαδικό δέντρο αναζήτησης και απλώς ακολουθήστε τον αλγόριθμο διάσχισης μετά την παραγγελία για τη λαμβάνονται BST.

Ξέρω ότι αυτό είναι παλιό, αλλά υπάρχει μια καλύτερη λύση.

Δεν έχουμε να ανακατασκευάσει μια BST για να πάρει τη θέση-παραγγελία από την προ-παραγγελία.

Εδώ είναι ένα απλό κώδικα python που το κάνει κατ 'επανάληψη:

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

Παραγωγή:

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

επεξήγηση :

Ξέρουμε ότι είμαστε σε προ-παραγγελία. Αυτό σημαίνει ότι η ρίζα είναι στο ευρετήριο 0του καταλόγου των τιμών στο BST. Και ξέρουμε ότι τα στοιχεία Ακολουθώντας τη διαδρομή είναι οι εξής:

• πρώτα: τα στοιχεία λιγότερο από το root, τα οποία ανήκουν στην αριστερά υποδένδρο της ρίζας
• δεύτερο: τα στοιχεία μεγαλύτερο από το root, τα οποία ανήκουν στην δεξιά υποδένδρο της ρίζας

Στη συνέχεια, απλά καλέστε αναδρομικά τη λειτουργία και στις δύο υποδένδρων (που εξακολουθούν να βρίσκονται σε προ-παραγγελία) και στη συνέχεια της αλυσίδας left + right + root(που είναι η μετα-παραγγελία).

Εάν σας έχει δοθεί προ-παραγγελία και θέλετε να το μετατρέψετε σε postorder. Στη συνέχεια, θα πρέπει να θυμόμαστε ότι σε μια BST, προκειμένου να δώσει πάντα τους αριθμούς σε αύξουσα order.Thus έχετε τόσο Inorder καθώς και την προ-παραγγελία για την κατασκευή ενός δέντρου.

παραγγελίας: 6, 2, 1, 4, 3, 7, 10, 9, 11

για να: 1, 2, 3, 4, 6, 7, 9, 10, 11

Και postorder της: 1 3 4 2 9 11 10 7 6

Εδώ προ-παραγγελία διάσχιση ενός δυαδικού δέντρου αναζήτησης δίνεται στη σειρά. Έτσι, το 1ο στοιχείο του πίνακα προ-παραγγελία θα ριζώσει της BST.We θα βρείτε το αριστερό μέρος της BST και το δεξί μέρος της BST.All το στοιχείο στη σειρά προ-παραγγελία είναι μικρότερη από ό, τι ρίζα θα μείνει κόμβο και Όλο το στοιχείο της προ συστοιχία -Τάξη είναι μεγαλύτερη τότε ρίζα θα είναι σωστό κόμβο.

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

Όπως γνωρίζουμε παραγγελίας ακολουθήσει γονέα, αριστερά, δεξιά σειρά.

Προκειμένου να κατασκευαστεί το δέντρο θα πρέπει να ακολουθήσετε μερικές βασικές βήματα-:

ερώτησή σας αποτελείται από σειρά 6, 2,1,4,3,7,10,9,11

σημεία-:

1. Πρώτη αριθμός σειράς θα είναι ρίζα (μητρική), δηλαδή 6

2.Find ο αριθμός που είναι μεγαλύτερος από 6 έτσι ώστε σε αυτή τη σειρά 7 είναι το πρώτο μεγαλύτερο αριθμό σε αυτή τη σειρά, ώστε το δικαίωμα κόμβος θα ξεκινήσει από εδώ και αριστερά σε αυτόν τον αριθμό (7) είναι αριστερά υποδένδρων σας.

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

τρόπο 3.same ακολουθήσει το βασικό κανόνα της BST δηλαδή αριστερά, ρίζα, το δικαίωμα

η σειρά των μετα παραγγελίας θα είναι L, R, N δηλαδή 1,3,4,2,9,11,10,7,6

Αυτό είναι ο κωδικός της παραγγελίας να postorder διάσχισης σε python. Είμαι κατασκευή ενός δέντρου, ώστε να μπορείτε να βρείτε οποιοδήποτε τύπο διάσχισης

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)

Εδώ είναι η πλήρης κωδικός)

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

Επειδή, είναι ένα δυαδικό δένδρο αναζήτησης, η διάσχιση inorder θα είναι πάντα τα ταξινομημένα στοιχεία. (Αριστερά <root <δεξιά)

έτσι, μπορείτε εύκολα να γράψετε τα αποτελέσματα της διάσχισης σε σειρά πρώτη, η οποία είναι: 1,2,3,4,6,7,9,10,11

δεδομένου Προ-παραγγελία: 6, 2, 1, 4, 3, 7, 10, 9, 11

Στην παραγγελία: αριστερά, ρίζα, δεξιά Προ-παραγγελία: ρίζα, αριστερά, δεξιά μετά τη σειρά: αριστερά, δεξιά, ρίζα

τώρα, πήραμε από την προ-παραγγελία, ότι η ρίζα είναι 6.

τώρα, με τη χρήση σε-σειρά και τα αποτελέσματα προ-παραγγελία: Βήμα 1:

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

Βήμα 2: επόμενη ρίζα είναι, χρησιμοποιώντας ίη-τάξης διάσχισης, 2:

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

Βήμα 3: Ομοίως, δίπλα ρίζα είναι 4:

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

Βήμα 4: επόμενο ρίζα είναι 3, αλλά κανένα άλλο στοιχείο που απομένει για να είναι κατάλληλο στο δέντρο παιδιού για «3». Θεωρώντας επόμενο ρίζα ως 7 τώρα,

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

Βήμα 5: Επόμενο ρίζα είναι 10:

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

Αυτό είναι το πώς, μπορείτε να κατασκευάσει ένα δέντρο, και, τέλος, να βρει διάσχιση μετα-διάταξή του, η οποία είναι: 1, 3, 4, 2, 9, 11, 10, 7, 6