Sorter Array før du legger til et binært søketre Java

Question

Sorter Array før du legger til et binært søketre Java

stemmer

0

Jeg har en tabell med strenger som er i orden AZ. Jeg lurte på den beste måten å gå om å sortere dem for et balansert binært søketre. Min første tanke er å splitte matrisen opp i første omgang og andre omgang, og deretter sortere dem individuelt.

Burde jeg ikke kunne bruke en rekursiv måte å holde splitte den i to for å få den neste Node for treet? Jeg kan bare ikke bryte hodet mitt rundt det akkurat nå, og tenkte jeg skulle spørre om noen hadde noen ideer. å lede meg i riktig retning eller gi noen eksempler. Takk!

Jeg bruker min egen BinærTre klasse og BinaryTreeNode klasse. REDIGERE:

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

vil dette anses som en selvbalanserende binært søketre?

java recursion binary-search-tree

Publisert på 07/11/2011 klokken 08:32
kilden bruker Pengume

På andre språk...

2 svar

stemmer

0

Hvis du har et binært søketre som er selvbalanserende det er ganske sikkert kontraproduktivt til pre-sortere tabellen. Algoritmen for optimalt å tilsette sorterte data til et balansert tre er ganske forskjellig fra algoritmen for å legge sorterte data.

Men det er ingenting 'selvbalanserende' om koden du postet. Det er bare en vanlig binærtreet innsetting algoritme.

Svarte 07/11/2011 kl. 08:37
kilden bruker EJP

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

Treet ser ikke ut til å være selvbalanserende. En selvbalanserende BST vil ta skritt, etter en innføring, eller etter en rekke innsetninger, for å sikre at den er (omtrent) balansert.

Hvis du bare legge elementene gang og bruke treet bare for leser, har du din sortert array og gjør du slik: Velg elementet i midten. skape en rot med det som nøkkel, og deretter rekursivt legge elementene til venstre for den (de mindre elementer) som den venstre undertreet på rot, og elementene til sin høyre som det høyre treet hhv. Du bør ende opp med en BST som er mer eller mindre balansert. Eksempel kode:

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

    /* ... */
}

Men i dette tilfellet, kan du bare holde elementene i den sorterte array, og bruke binære søk for å indeksere inn i det, i stedet for et tre. Kompleksiteten bør være den samme, O (LOGN), men du trenger mindre referanser til å lagre hele greia, og cache ytelse bør være bedre.

Hvis du trenger å ha en foranderlig tre, og ønsker å gjøre det effektivt, vil du sannsynligvis trenger å gjøre det selv-balansert, sak der den rekkefølgen du legge til elementer i det spiller ingen rolle.