sorta Array prima di aggiungere ad un albero binario di ricerca Java

Question

sorta Array prima di aggiungere ad un albero binario di ricerca Java

voti

0

Ho una matrice di stringhe che sono in ordine AZ. Mi chiedevo il modo migliore per andare su di loro l'ordinamento di un equilibrato albero binario di ricerca. Il mio pensiero iniziale è quella di dividere la matrice fino nella prima metà e la seconda metà e poi ordinarli singolarmente.

Non dovrei essere in grado di utilizzare un modo ricorsivo per mantenere dividendolo a metà per ottenere il prossimo nodo per l'albero? Non riesco proprio a avvolgere la mia testa intorno ad esso in questo momento e ho pensato chiedere se qualcuno avesse qualche idea. a me condurre nella giusta direzione o fornire alcuni esempi. Grazie!

Sto usando il mio BinaryTree Classe A e Classe BinaryTreeNode. MODIFICARE:

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

questo sarebbe considerato un auto bilanciamento albero binario di ricerca?

java recursion binary-search-tree

È pubblicato 07/11/2011 alle 09:32
fonte dall'utente Pengume

In altre lingue...

2 risposte

voti

0

Se si dispone di un albero binario di ricerca che si auto-equilibratura è molto probabilmente controproducente per pre-ordinare l'array. L'algoritmo in modo ottimale per l'aggiunta di dati ordinati ad un albero bilanciato è molto diversa da l'algoritmo per l'aggiunta di dati non ordinati.

Tuttavia non c'è nulla di 'auto-bilanciamento' circa il codice che avete inviato. E 'solo un algoritmo binario normale inserimento albero.

Risposto il 07/11/2011 a 09:37
fonte dall'utente EJP

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

Il tuo albero non sembra essere auto bilanciamento. Un BST autoequilibrante adotterà misure, dopo un inserimento, o dopo un numero di inserzioni, per assicurare che sia (approssimativamente) equilibrata.

Se si aggiungono solo gli elementi una volta e utilizza l'albero solo per legge, avete la vostra array ordinato e quindi procedere come segue: Selezionare l'elemento al centro. creare una directory principale con esso, come chiave, e quindi ricorsivamente aggiungere gli elementi alle sue (gli elementi più piccoli) ha lasciato come sottoalbero sinistro della radice, e gli elementi alla sua destra come il sottoalbero destro, rispettivamente. Si dovrebbe finire con un BST che è più o meno equilibrata. Esempio di codice:

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

    /* ... */
}

Tuttavia, in questo caso, si potrebbe semplicemente tenere gli elementi in array ordinato, e usare la ricerca binaria per indicizzare in esso, invece di un albero. La complessità dovrebbe essere la stessa, O (log), ma avete bisogno di meno i riferimenti per memorizzare il tutto, e le prestazioni della cache dovrebbe essere migliore.

Se avete bisogno di avere un albero mutabile, e vuole renderlo efficiente, si sarebbe probabilmente necessario rendere auto-bilanciato, caso in cui l'ordine in cui si aggiungono gli elementi ad esso non importa.