avant d'ajouter sorte tableau à un arbre de recherche binaire Java

Question

avant d'ajouter sorte tableau à un arbre de recherche binaire Java

voix

0

J'ai un tableau de chaînes qui sont pour AZ. Je me demandais la meilleure façon d'aller sur les trier pour un arbre de recherche binaire équilibré. Ma première pensée est de diviser le tableau vers le haut dans la première moitié et la seconde moitié, puis les trier individuellement.

Je ne devrais pas être en mesure d'utiliser une façon récursive pour maintenir le diviser en deux pour obtenir le prochain nœud pour l'arbre? Je ne peux pas envelopper la tête autour d'elle en ce moment et pensé que je demanderais si quelqu'un avait des idées. pour me conduire dans la bonne direction ou donner quelques exemples. Merci!

J'utilise ma propre BinaryTree classe et BinaryTreeNode classe. MODIFIER:

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

cela serait considéré comme un arbre de recherche binaire auto équilibrage?

java recursion binary-search-tree

Créé 07/11/2011 à 09:32
source utilisateur Pengume

Dans d'autres langues...

2 réponses

voix

0

Si vous avez un arbre de recherche binaire qui est auto-équilibrage, il est tout à fait sans doute contre-productif de pré-trier le tableau. L'algorithme permettant d'ajouter de façon optimale des données triées à un arbre équilibré est tout à fait différent de l'algorithme pour ajouter des données non ordonnées.

Cependant, il n'y a rien « auto-équilibre » sur le code affiché. Il est juste un algorithme d'insertion d'arbre binaire ordinaire.

Créé 07/11/2011 à 09:37
source utilisateur EJP

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

Votre arbre ne semble pas être auto équilibre. Un BST autoéquilibré prendra des mesures, après une insertion, ou après un certain nombre d'insertions, de veiller à ce qu'il est ( à peu près) équilibrée.

Si vous ajoutez uniquement les éléments une fois et utilisez l'arbre juste pour lit, vous avez votre tableau trié, puis procédez comme suit: sélectionnez l'élément au milieu. créer une racine avec comme clé, puis récursive ajouter les éléments à sa gauche (les plus petits éléments) que la sous-arborescence à gauche de la racine, et les éléments à sa droite comme le sous-arbre droit, respectivement. Vous devriez finir avec un BST qui est plus ou moins équilibrée. Exemple de 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;
    }

    /* ... */
}

Cependant, dans ce cas, vous pouvez simplement garder vos éléments dans le tableau trié, et utiliser la recherche binaire pour les indexer, au lieu d'un arbre. La complexité doit être le même, O (logn), mais vous avez besoin de moins de références pour stocker le tout, et les performances du cache devrait être mieux.

Si vous avez besoin d'avoir un arbre mutable, et que vous voulez le rendre efficace, vous auriez probablement besoin de faire l'auto-équilibré, cas où l'ordre dans lequel vous ajoutez vos éléments à peu importe.