Ordenar un array antes de añadir a un árbol binario de Java Buscar

Question

Ordenar un array antes de añadir a un árbol binario de Java Buscar

votos

0

Tengo una matriz de cadenas que están en orden AZ. Me preguntaba la mejor manera de ir sobre la clasificación de ellos por un árbol binario de búsqueda equilibrado. Mi idea inicial es dividir la matriz de arriba en la primera mitad y la segunda mitad y luego ordenarlos de forma individual.

¿No debería ser capaz de utilizar de manera recursiva para mantener la división por la mitad para obtener el siguiente nodo del árbol? No puedo envolver mi cabeza alrededor de ella en este momento y pensaba que iba a preguntar si alguien tenía alguna idea. me llevan en la dirección correcta o proporcionar algunos ejemplos. ¡Gracias!

estoy usando mi propia BinaryTree Clase y Clase BinaryTreeNode. EDITAR:

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

esto se consideraría un autobalanceo árbol binario de búsqueda?

java recursion binary-search-tree

Publicado el 07/11/2011 a las 09:32
fuente por usuario Pengume

En otros idiomas...

2 respuestas

votos

0

Si usted tiene un árbol de búsqueda binaria que es auto-equilibrio es muy probable contraproducente para pre-ordenar la matriz. El algoritmo para la adición de datos ordenados de manera óptima a un árbol de equilibrado es bastante diferente del algoritmo para añadir datos sin ordenar.

Sin embargo no hay nada 'auto-equilibrado' sobre el código que envió. Es sólo un algoritmo de inserción de árbol binario ordinario.

Respondida el 07/11/2011 a las 09:37
fuente por usuario EJP

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

Su árbol no parece ser el equilibrio de uno mismo. A BST auto-equilibrio tomará medidas, después de una inserción, o después de un número de inserciones, para asegurarse de que es (más o menos) equilibrada.

Si se agrega sólo los elementos de una vez y utilizar el árbol sólo para lee, usted tiene su matriz ordenada y luego proceder de la siguiente manera: selecciona el elemento en el medio. crear una raíz con él como clave, y luego añadir de forma recursiva los elementos a su izquierda (los elementos más pequeños) como el subárbol izquierdo de su raíz, y los elementos a su derecho como el subárbol derecho, respectivamente. Usted debe terminar con un BST que es más o menos equilibrada. Código de ejemplo:

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

    /* ... */
}

Sin embargo, en este caso, usted podría simplemente mantener los elementos en la matriz ordenada, y usar la búsqueda binaria para indexar en que, en lugar de un árbol. La complejidad debe ser el mismo, O (log n), pero se necesita menos referencias para almacenar todo el asunto, y el rendimiento de la caché debe ser mejor.

Si usted necesita tener un árbol mutable, y quiere que sea eficiente, lo que probablemente necesita para que sea auto-equilibrado, caso en el que el orden en que se agregan los elementos que no importa.