बाद आदेश ट्रावर्सल को अग्रिम आदेश दें

प्री-ऑर्डर करें = वर्तमान नोड, फिर बाएं सबट्री, तो सही सबट्री के क्रम में एक द्विआधारी पेड़ के मूल्यों outputting।

पोस्ट-आदेश = बाएं सबट्री, तो सही सबट्री, वर्तमान नोड के क्रम में एक द्विआधारी पेड़ के मूल्यों outputting।

एक द्विआधारी में खोज पेड़, बाईं सबट्री में सभी नोड्स के मूल्यों वर्तमान नोड के मूल्य से कम कर रहे हैं; और सही सबट्री के लिए एक जैसे। इसलिए अगर आप एक द्विआधारी खोज वृक्ष की एक पूर्व आदेश डंप की शुरुआत पता (अपने रूट नोड के मूल्य यानी), आप आसानी से रूट नोड मूल्य में पूरी डंप विघटित कर सकते हैं, बाईं सबट्री के नोड्स के मूल्यों, और के मूल्यों सही सबट्री नोड्स।

उत्पादन करने के लिए बाद के क्रम में पेड़, प्रत्यावर्तन और आउटपुट पुनर्व्यवस्था लागू किया जाता है। इस कार्य पाठक पर छोड़ दिया है।

ओंद्रेज Tucny के जवाब के आधार पर। BST केवल के लिए मान्य
उदाहरण:

     20  
    /  \  
   10  30  
   /\    \  
  6  15   35  

Preorder = 20 10 6 15 30 35
पोस्ट = 6 15 10 35 30 20

एक BST, Preorder ट्रेवर्सल में है; सरणी के पहले तत्व है 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 फिर से संगठित करने प्री-ऑर्डर के उत्तर-आदेश प्राप्त करने के लिए नहीं है।

यहाँ एक सरल अजगर कोड है कि यह रिकर्सिवली करता है:

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]

स्पष्टीकरण :

हम जानते हैं कि हम पहले से क्रम में हैं। इसका मतलब है कि जड़ सूचकांक पर है 0BST में मानों की सूची की। और हम जानते हैं कि जड़ निम्नलिखित तत्व हैं:

• पहली: कम से कम तत्व rootहै, जो जड़ के बाईं सबट्री से संबंध रखते हैं
• दूसरा: इससे बड़ी तत्व rootहै, जो रूट की सही सबट्री से संबंध रखते हैं

हम तो बस रिकर्सिवली दोनों subtrees पर समारोह (जो अभी भी पूर्व क्रम में हैं) और फिर श्रृंखला फोन left + right + root(जो बाद आदेश है)।

आप अग्रिम आदेश दिया गया हो और आप इसे क्रंमोत्तर में तब्दील करना चाहते हैं। तो फिर तुम क्रम में हमेशा आरोही में संख्या देना याद रखना चाहिए कि एक BST में order.Thus आप अग्रिम आदेश के एक पेड़ के निर्माण के लिए और साथ ही दोनों के लिए inorder है।

पूर्व आदेश: 6, 2, 1, 4, 3, 7, 10, 9, 11

क्रम में: 1, 2, 3, 4, 6, 7, 9, 10, 11

और इसकी क्रंमोत्तर: 1 3 4 2 9 11 10 7 6

यहाँ एक द्विआधारी खोज वृक्ष की प्री-ऑर्डर ट्रेवर्सल सरणी में दिया जाता है। तो प्री-ऑर्डर सरणी के 1 तत्व BST.We की जड़ जाएगा BST और BST.All की सही भाग के बाएं हिस्से मिलेगा प्री-ऑर्डर सरणी में तत्व कम से रूट नोड छोड़ दिया जाएगा है और पूर्व के सभी तत्व -order सरणी अधिक से अधिक तो जड़ सही नोड हो जाएगा।

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

हम Preorder माता-पिता, बाएँ, दाएँ श्रृंखला का पालन जानते हैं।

आदेश पेड़ के निर्माण के लिए हम कुछ बुनियादी steps- पालन करने की आवश्यकता:

अपने प्रश्न श्रृंखला 6 से मिलकर बनता है, 2,1,4,3,7,10,9,11

अंक:

1. शृंखला का पहला नंबर जड़ हो जाएगा (पैरेंट) यानी 6

2.Find संख्या है जो इस श्रृंखला 7 में अधिक से अधिक से अधिक 6 तो पहले अधिक से अधिक संख्या तो सही नोड यहाँ से शुरू हो जाएगा इस श्रृंखला में और इस संख्या के लिए छोड़ दिया (7) अपने बाएँ subtrees है।

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

3.same रास्ता BST यानी छोड़ दिया है, जड़ का बुनियादी नियम, सही पालन

पोस्ट आदेश की श्रृंखला हो जाएगा एल, आर, एन यानी 1,3,4,2,9,11,10,7,6

यह अग्रिम आदेश के कोड अजगर में ट्रेवर्सल क्रंमोत्तर है। मैं एक पेड़ के निर्माण कर रहा हूँ ताकि आप ट्रेवर्सल किसी भी प्रकार प्राप्त कर सकते हैं

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 ट्रावर्सल हमेशा रहेंगे क्रमबद्ध तत्व हो। (बाएं <जड़ <दाएं)

हां, तो आप आसानी से अपने इन-आदेश ट्रावर्सल परिणाम पहले लिख सकते हैं, जो: 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

, 6 1, 3, 4, 2, 9, 11, 10, 7: यह कैसे है, तो आप एक पेड़ का निर्माण कर सकते हैं और अंत में इसके बाद के क्रम ट्रेवर्सल है, जो लगता है