wie BST mit {pre, in, post} um Traversierungen Ergebnisse für den Wiederaufbau

Weil es BST ist, in-orderkann von sortiert werden pre-orderoder post-order<1>. Eigentlich entweder pre-orderoder post-orderwird nur dann benötigt ....

<1>, wenn Sie wissen, was die Vergleichsfunktion ist

Von pre-orderund in-ordereinen binären Baum zu konstruieren

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

Die Logik dahinter:

In vorbestellbarer, ist der erste Knoten die Wurzel. Finden Sie die Wurzel in der in Ordnung. Dann kann der Baum in links und rechts aufgeteilt werden. Tun Sie es rekursiv.

Ähnliche für post-orderund in-order.

Ich persönlich fand Dante Antwort ein wenig schwer zu folgen. Ich arbeitete mich durch die Lösung und fand es auf die hier gepostet ähnlich sein http://geeksforgeeks.org/?p=6633

Komplexität O (N ^ 2).

Hier ist ein weiterer Ansatz für den Aufbau eines Baumes mit Post-Order Traversal: http://www.technicallyidle.com/2011/02/15/build-binary-search-tree-using-post-order-traversal-trace/

Hoffe das hilft

Zur Rekonstruktion eines binären Baums entweder vorbestellen + Inorder oder Postorder + Inorder benötigt. Wie bereits für einen BST wies darauf hin, können wir entweder vorbestellen oder Postorder rekonstruieren, wie einer von ihnen Sortierung wird uns die Inorder geben.

Sie können die folgende Funktion verwenden, die durch @brainydexter gegebene Änderung des Codes ist, den Baum zu rekonstruieren, ohne die statische Variable:

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

Hier ist eine Ruby rekursive Lösung

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

Und ein Beispiel

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