πώς να ανοικοδόμηση BST χρησιμοποιώντας {προ, κατά, μετά} αποτελέσματα διελεύσεων τάξης

Επειδή είναι 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 ή postorder + inorder είναι απαραίτητη. Όπως έχει ήδη επισημανθεί για μια BST μπορούμε να ανακατασκευάσει χρησιμοποιώντας είτε προ-παραγγελία ή postorder όπως διαλογή, είτε από αυτούς θα μας δώσει την 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;
}

Εδώ είναι μια αναδρομική λύση Ruby

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