hvordan å gjenoppbygge BST med {pre, i, etter} rekkefølge gjennomløping resultatene

Fordi det er BST, in-orderkan sorteres fra pre-ordereller post-order<1>. Egentlig enten pre-ordereller post-ordertrengs bare ....

<1> hvis du vet hva sammenligningen funksjonen er

Fra pre-orderog in-order, å konstruere et binært tre

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

Begrunnelsen for dette:

I pre-orden, er den første noden roten. Finn roten i in-order. Da treet kan deles inn i venstre og høyre. Gjør det rekursivt.

Lignende for post-orderog in-order.

Jeg personlig fant Dantes svar litt vanskelig å følge. Jeg jobbet meg gjennom løsningen, og fant det å være lik den lagt ut her http://geeksforgeeks.org/?p=6633

Kompleksitet O (N ^ 2).

Her er en annen tilnærming for å bygge et tre ved hjelp av post-order traversering: http://www.technicallyidle.com/2011/02/15/build-binary-search-tree-using-post-order-traversal-trace/

Håper dette hjelper

For rekonstruksjon av et binært tre enten forhåndsbestilling + inorder eller Postorder + inorder er nødvendig. Som allerede påpekt for en BST kan vi rekonstruere ved hjelp av enten forhåndsbestilling eller Postorder som sortering noen av dem vil gi oss inorder.

Man kan bruke følgende funksjon, som er modifikasjon av den koden som er gitt ved @brainydexter å rekonstruere treet uten å bruke den statiske variabelen:

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

Her er en Ruby rekursiv løsning

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

Og et eksempel

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