कैसे BST {, पूर्व में, पोस्ट} का उपयोग क्रम traversals परिणाम के पुनर्निर्माण के लिए

क्योंकि यह BST है, in-orderसे हल हो सकते हैं pre-orderया post-order<1>। वास्तव में, या तो pre-orderया post-orderकेवल जरूरत है ....

<1> क्या आप जानते तुलना समारोह है क्या हुआ अगर

से pre-orderऔर in-order, एक द्विआधारी पेड़ के निर्माण के लिए

BT createBT(int* preOrder, int* inOrder, int len)
{
    int i;
    BT tree;
    if(len <= 0)
        return NULL;
    tree = new BTNode;
    t->data = *preOrder;
    for(i = 0; i < len; i++)
        if(*(inOrder + i) == *preOrder)
            break;
    tree->left = createBT(preOrder + 1, inOrder, i);
    tree->right = createBT(preOrder + i + 1, inOrder + i + 1, len - i - 1);
    return tree;
}

इस के पीछे तर्क:

प्री-ऑर्डर में, पहली नोड जड़ है। इन-क्रम में जड़ का पता लगाएं। फिर पेड़ छोड़ दिया और सही में विभाजित किया जा सकता है। यह रिकर्सिवली करो।

के लिए इसी तरह post-orderऔर in-order।

मैं व्यक्तिगत रूप से दांते की जवाब एक छोटे से पालन करने के लिए मुश्किल पाया। मैं समाधान के माध्यम से अपने रास्ते काम किया है और पाया है कि यह एक यहां पोस्ट के समान होने की http://geeksforgeeks.org/?p=6633

जटिलता हे (एन ^ 2) है।

यहाँ के बाद आदेश ट्रावर्सल का उपयोग कर एक पेड़ के निर्माण के लिए एक और तरीका है: http://www.technicallyidle.com/2011/02/15/build-binary-search-tree-using-post-order-traversal-trace/

उम्मीद है की यह मदद करेगा

एक द्विआधारी पेड़ या तो अग्रिम आदेश के पुनर्निर्माण के लिए + inorder या क्रंमोत्तर + inorder की जरूरत है। जैसा कि पहले ही एक BST के लिए कहा हम के रूप में छँटाई उनमें से या तो हमें inorder दे देंगे या तो अग्रिम आदेश या क्रंमोत्तर का उपयोग कर फिर से संगठित कर सकते हैं।

आप नीचे दिए गए समारोह जो @brainydexter द्वारा दिए गए स्थिर चर का उपयोग किए बिना पेड़ फिर से संगठित करने कोड के संशोधन का उपयोग कर सकते हैं:

struct node* buildTree(char in[],char pre[], int inStrt, int inEnd,int preIndex){

    // start index > end index..base condition return NULL.
    if(inStrt > inEnd)
        return NULL;

    // build the current node with the data at pre[preIndex].
    struct node *tNode = newNode(pre[preIndex]);

    // if all nodes are constructed return. 
    if(inStrt == inEnd)
        return tNode;

    // Else find the index of this node in Inorder traversal
    int inIndex = search(in, inStrt, inEnd, tNode->data);

    // Using index in Inorder traversal, construct left and right subtress
    tNode->left = buildTree(in, pre, inStrt, inIndex-1,preIndex+1);
    tNode->right = buildTree(in, pre, inIndex+1, inEnd,preIndex+inIndex+1);

    return tNode;
}

यहाँ एक रूबी पुनरावर्ती समाधान है

def rebuild(preorder, inorder)
  root = preorder.first
  root_inorder = inorder.index root
  return root unless root_inorder
  root.left = rebuild(preorder[1, root_inorder], inorder[0...root_inorder])
  root.right = rebuild(preorder[root_inorder+1..-1], inorder[root_inorder+1..-1])
  root
end

और एक उदाहरण

class Node
  attr_reader :val
  attr_accessor :left, :right

  def initialize(val)
    @val = val
  end

  def ==(node)
    node.val == val
  end

  def inspect
    "val: #{val}, left: #{left && left.val || "-"}, right: #{right && right.val || "-"}"
  end
end

inorder = [4, 7, 2, 5, 1, 3, 8, 6, 9].map{|v| Node.new v }
preorder = [1, 2, 4, 7, 5, 3, 6, 8, 9].map{|v| Node.new v }

tree = rebuild(preorder, inorder)
tree
# val: 1, left: 2, right: 3
tree.left
# val: 2, left: 4, right: 5
tree.left.left
# val: 4, left: -, right: 7