sortare Array înainte de a adăuga la un binar de căutare copac Java

voturi
0

Am o serie de coarde, care sunt în ordine AZ. Mă întrebam cel mai bun mod de a merge cu privire la sortarea lor pentru un arbore echilibrat binar de căutare. Gândul meu inițial este de a împărți matrice până în prima jumătate a anului și a doua jumătate și apoi sortați-le în mod individual.

Nu ar trebui să fie în măsură să utilizeze un mod recursiv de a păstra divizarea în jumătate pentru a obține următorul nod pentru copac? Pur și simplu nu se poate încadra în jurul valorii de capul meu chiar acum și am crezut că ar întreba dacă cineva avea vreo idee. să mă conducă în direcția corectă sau să ofere câteva exemple. Mulțumiri!

Sunt folosind propria mea BinaryTree clasa si BinaryTreeNode clasa. EDITAȚI | ×:

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

ar fi considerat acest lucru un autoechilibrare arbore binar de căutare?

Întrebat 07/11/2011 la 09:32
sursa de către utilizator
În alte limbi...                            


2 răspunsuri

voturi
0

Dacă aveți un arbore binar de căutare, care este auto-echilibrare este destul de probabil, contra-productivă a pre-sortare matrice. Algoritmul pentru adăugarea optim datele sortate la un arbore echilibrat este destul de diferit de algoritmul pentru adăugarea de date neordonate.

Cu toate acestea nu este nimic „auto-echilibrare“ despre codul curent. Acesta este doar un algoritm binar de inserare copac obișnuit.

Publicat 07/11/2011 la 09:37
sursa de către utilizator

voturi
1

Copacul tău nu pare a fi auto - echilibrare. Un BST auto - echilibrare va lua măsuri, după o inserție, sau după un număr de inserții, pentru a se asigura că aceasta este (aproximativ) echilibrată.

Dacă adăugați doar elementele de dată și de a folosi copac doar pentru citește, ai matrice dvs. sortat și apoi procedați după cum urmează: selectați elementul din mijloc. a crea o rădăcină cu ea ca fiind cheia, apoi adăugați recursiv elementele la stânga (elementele mai mici) sale ca subarborele stâng al rădăcină, și elementele dreptului său ca subarborelui drept, respectiv. Ar trebui să se încheie cu un BST care este mai mult sau mai puțin echilibrat. Exemplu de cod:

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

    /* ... */
}

Cu toate acestea, în acest caz, ai putea pur și simplu păstrați elementele într-o matrice sortat, și de a folosi binar de căutare pentru a indexa în ea, în loc de un copac. Complexitatea ar trebui să fie aceeași, O (logn), dar ai nevoie de mai puține referințe pentru a stoca totul, și performanța cache ar trebui să fie mai bine.

Dacă aveți nevoie de a avea un copac mutabil, și doresc să facă eficient, probabil ai nevoie să-l auto-echilibrat, caz în care ordinea în care adăugați elemente pentru a nu contează face.

Publicat 07/11/2011 la 09:51
sursa de către utilizator

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more