Art Array vor einem binären Suchbaum Java zum Hinzufügen

Question

Art Array vor einem binären Suchbaum Java zum Hinzufügen

stimmen

0

Ich habe ein Array von Strings, die in Reihenfolge AZ sind. Ich habe mich gefragt, den besten Weg zu gehen, um sie für einen ausgewogenen binären Suchbaum sortiert werden. Mein erster Gedanke ist das Array bis in die erste Hälfte und die zweite Hälfte aufzuteilen und sie dann einzeln sortieren.

Soll ich nicht eine rekursive Art und Weise nutzen kann, damit es in zwei Hälften teilen den nächsten Knoten für den Baum zu bekommen? Ich kann einfach nicht wickeln, meinen Kopf um es jetzt und dachte, ich würde fragen, ob jemand irgendwelche Ideen hatte. mich in der richtigen Richtung zu führen oder einige Beispiele. Vielen Dank!

Ich bin mit meiner eigenen BinaryTree Klasse und BinaryTreeNode Klasse. BEARBEITEN:

public class BinaryTree {
private BinaryTreeNode root;

public void insert(String text) {

root = insertNode(root, text); 

}

private BinaryTreeNode insertNode(BinaryTreeNode curNode, String text) {
if (curNode == null) {
    BinaryTreeNode newNode = new BinaryTreeNode(text);
    //newNode.value = text;
    return newNode;
} else {
    if (text.compareTo(curNode.value) < 0 ) {
        //left child
        //use of recursion to properly place Node
        curNode.left = insertNode(curNode.left, text);
        return curNode;
    }

        else {

        //right
        //use of recursion to properly place Node
        curNode.right = insertNode(curNode.right, text);
        return curNode;
    }
}

}

public BinaryTreeNode getRoot() {
return root;
}

 public void setRoot(BinaryTreeNode root) {
this.root = root;
 }
 }

würde dies eine Selbstausgleich binären Suchbaumes in Betracht gezogen werden?

java recursion binary-search-tree

Veröffentlicht am 07/11/2011 um 09:32
quelle vom benutzer Pengume

In anderen Sprachen...

2 antworten

stimmen

0

Wenn Sie einen binären Suchbaum haben, ist selbstausgleich es ziemlich wahrscheinlich kontraproduktiv ist das Array vorge sortieren. Der Algorithmus für die optimal sortierten Daten zu einem ausgeglichenen Baum hinzuzufügen, ist ganz verschieden von dem Algorithmus zum Hinzufügen von ungeordneten Daten.

Allerdings gibt es nichts ‚Selbstausgleich‘ über den Code Sie auf dem Laufenden. Es ist nur ein gewöhnlicher Binärbaum Einfügungsalgorithmus.

Beantwortet am 07/11/2011 um 09:37
quelle vom benutzer EJP

Vlad · Accepted Answer · 2011-11-07 09:51

Ihr Baum scheint nicht selbstAusgleich zu sein. Ein selbstausgleich BST wird Maßnahmen ergreifen, nach einer Insertion oder nach einer bestimmten Anzahl von Einfügungen, um sicherzustellen , dass es ( in etwa) ausgeglichen ist.

Wenn Sie nur die Elemente einmal hinzufügen und den Baum verwenden nur liest, haben Sie Ihre sortierten Array und dann gehen Sie wie folgt vor: Wählen Sie das Element in der Mitte. schaffen eine Wurzel mit ihm als Schlüssel, und fügen Sie dann rekursiv die Elemente zu ihrer Linken (die kleineren Elemente) als linke Unterbaum Ihrer Wurzel, und die Elemente zu ihrem Recht als rechten Teilbaum sind. Sie sollten mit einem BST am Ende, die mehr oder weniger ausgeglichen ist. Beispielcode:

public class BinaryTree {

    /* ... */


    //each recursive call receives a pair of bounds for the part of the 
    //array it has to process: left and right
    public static BinaryTreeNode nodeFromSortedArray(String[]a,
                                           int left, int right){

        if (right<left) return null;

        if (right==left)
            return new BinaryTreeNode(a[left]);

        int mid = (left+right)/2;

        //create node from middle element
        BinaryTreeNode n = new BinaryTreeNode(a[mid]);

        //recursively add elements to the left as its right subtree
        n.left = nodeFromSortedArray(a, left, mid-1);

        //recursively add elements to the right as its right subtree
        n.right = nodeFromSortedArray(a, mid+1, right);

        return n;
    }

    public static BinaryTree fromSortedArray(String[]a){
        BinaryTree bt = new BinaryTree();
        bt.setRoot(nodeFromSortedArray(a,0,a.length-1));
        return bt;
    }

    /* ... */
}

Doch in diesem Fall können Sie einfach Ihre Elemente im sortierten Feld halten, und verwenden Sie binäre Suche indiziert hinein, statt einem Baum. Die Komplexität sollte die gleiche, O (log n) sein, aber Sie müssen weniger Referenzen, die ganze Sache zu speichern, und Cache-Leistung sollte besser sein.

Wenn Sie einen wandelbaren Baum haben müssen, und wollen sie effizienter machen, müssen Sie wahrscheinlich, um es selbst ausgeglichen zu machen, Fall, in dem die Reihenfolge, in der Sie Ihre Elemente hinzufügen, um es spielt keine Rolle.