sort Array voor het toevoegen aan een Binary Zoekboom Java

Question

sort Array voor het toevoegen aan een Binary Zoekboom Java

stemmen

0

Ik heb een array van strings die in orde zijn AZ. Ik vroeg me af de beste manier om te gaan ze te sorteren voor een evenwichtige binaire zoekboom. Mijn eerste gedachte is om de serie te splitsen in de eerste helft en de tweede helft en vervolgens te sorteren hen individueel.

Zou ik niet in staat zijn om een recursieve manier te gebruiken te houden splitsen in de helft naar het volgende knooppunt voor de boom te krijgen? Ik kan het gewoon niet sla mijn hoofd rond het juist nu en dacht dat ik zou vragen als iemand enig idee had. om me te leiden in de juiste richting of geef enkele voorbeelden. Bedankt!

Ik gebruik mijn eigen BinaryTree Class en BinaryTreeNode Class. BEWERK:

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

zou dit een Self balancing binaire zoekboom worden beschouwd?

java recursion binary-search-tree

De vraag is gesteld op 07/11/2011 om 09:32
bron van user Pengume

In andere talen...

2 antwoorden

stemmen

0

Als u een binary search boom die self-balancing is het heel waarschijnlijk contra-productief voor een pre-sorteren array. Het algoritme voor het optimaal toe te voegen naargelang data om een evenwichtige boom is heel anders dan het algoritme voor het toevoegen van ongeordende data.

Er is echter niets 'self-balancing' over de code u op de hoogte. Het is gewoon een gewone binaire boom inbrengen algoritme.

antwoordde op 07/11/2011 om 09:37
bron van user EJP

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

Uw boom lijkt niet om zichzelf in evenwicht zijn. Een zelfbalancerende BST zullen maatregelen nemen, na insertie, of na een aantal inserties, zodat het (ongeveer) gebalanceerd.

Als je alleen de elementen toe te voegen eens en de boom alleen voor leest gebruiken, moet u uw gesorteerde array en ga dan als volgt: selecteert u het element in het midden. het creëren van een wortel met het als de belangrijkste, en vervolgens recursief de elementen aan de linkerkant (de kleinere elementen) als de linker deelboom van je root, en de elementen toe te voegen aan haar recht als de rechter deelboom, respectievelijk. U moet eindigen met een BST dat is min of meer in evenwicht. Voorbeeld code:

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

    /* ... */
}

Echter, in dit geval, kan je gewoon je elementen houden in de gesorteerde array en gebruik binary search te indexeren in het, in plaats van een boom. De complexiteit moet hetzelfde zijn, O (logn), maar je moet minder verwijzingen naar de hele zaak op te slaan, en cache prestaties beter moeten worden.

Als u nodig hebt om een veranderlijk boom te hebben, en willen dat het efficiënter te maken, zou je waarschijnlijk nodig om het self-evenwichtig, geval waarin de volgorde waarin u uw elementen toe te voegen aan het niet uit te maken.