Предзаказ на пост порядка обхода

Предварительный заказ = вывод значения двоичного дерева в порядке текущего узла, то левое поддерево, затем правое поддерево.

Сообщение порядка = вывод значения двоичного дерева в порядке левого поддерева, затем правое поддерево, то текущий узел.

В бинарной поиска дерева, значения всех узлов в левом поддереве меньше , чем значение текущего узла; и так для правого поддерева. Поэтому , если вы знаете , начало предзаказа сброса двоичного дерева поиска (то есть значение своего корневого узла), вы можете легко разложить весь дамп в значение корневого узла, значение узлов левого поддерева, а значения узлы правого поддерева в.

Для вывода дерева в пост-порядке, рекурсии и выход переупорядочивание применяется. Эта задача остается на читателя.

На основании ответа Ондрей 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, чтобы получить пост-заказ от предварительного заказа.

Вот простой питон код, который делает это рекурсивно:

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

Здесь предзаказ обход бинарного дерева поиска задается в массиве. Таким образом, первый элемент массива предзаказа будет корень из 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;
} 

Как мы знаем PREORDER следовать родительскую, левый, правый ряд.

Для построения дерева мы должны следовать несколько основных steps-:

Ваш вопрос состоит из серии 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 обхода в питона. Я построение дерева, так что вы можете найти любой тип обхода

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

Так как, это бинарное дерево поиска, то Симметричный обход будет всегда отсортированные элементы. (Слева <корень <справа)

таким образом, вы можете легко записать свои результаты обхода в первом порядка, который: 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