rendezés Array hozzáadása előtt bináris kereső fába Java

Question

rendezés Array hozzáadása előtt bináris kereső fába Java

szavazat

0

Van egy tömböt, amelyek ahhoz AZ. Csodálkoztam, hogy a legjobb módja annak, hogy megy a válogatás őket kiegyensúlyozott bináris kereső fába. A kezdeti gondolat, hogy osztott a tömb fel az első félidőben, a második felét, majd rendezni őket egyenként.

Nem kellene, hogy képes legyen használni rekurzív módon, hogy ketté félbe, hogy a következő csomópont a fát? Egyszerűen nem tudok fejem körül, és most gondoltam volna kérni, ha valaki volt olyan ötleteket. vezet engem a helyes irányba, vagy néhány példát. Kösz!

Én használ saját BinaryTree Class és BinaryTreeNode Class. EDIT:

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

lenne ez tekinthető önkiegyensúlyozást bináris keresési fa?

java recursion binary-search-tree

A kérdést 07/11/2011 09:32
a forrás felhasználó Pengume

Más nyelveken...

2 válasz

szavazat

0

Ha van egy bináris keresési fa, amely önkiegyensúlyozó elég valószínűleg kontraproduktív előre rendezni a tömböt. Az algoritmus optimálisan hozzátéve rendezni az adatokat egy kiegyensúlyozott fa meglehetősen eltér az algoritmus hozzátéve rendezetlen adatok.

Azonban nincs semmi „self-kiegyensúlyozó” a kódot írt. Ez csak egy közönséges bináris fa beszúrás algoritmusa.

Válaszolt 07/11/2011 09:37
a forrás felhasználó EJP

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

A fa nem úgy tűnik, hogy önkiegyensúlyozást. A önkiegyensúlyozó BST megteszi a szükséges lépéseket, miután egy behelyezése után vagy több betoldások, annak érdekében, hogy (nagyjából) kiegyensúlyozott.

Ha csak hozzá az elemek és a használat után a fa csak olvas, akkor a rendezett tömbben, majd folytassuk a következőképpen: válassza ki az elemet a közepén. hozzon létre egy gyökér vele, gombot, majd rekurzívan hozzáadni az elemeket, hogy a bal (a kisebb elemek), mint a bal részfa a gyökér, és az elemek azon jogát, mint a jobb részfa, ill. Meg kell a végén egy BST hogy többé-kevésbé kiegyensúlyozott. Példa kód:

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

    /* ... */
}

Azonban ebben az esetben, akkor csak tartsa a elemet a rendezett tömbben, és a bináris keresést index bele, hanem egy fa. A komplexitás meg kell egyeznie, O (logn), de meg kell kevesebb utalást tárolni az egészet, és a cache teljesítménye jobban kell.

Ha szükség van egy változékony fát, és szeretné, hogy ez hatékony, azt valószínűleg kell, hogy önálló, kiegyensúlyozott, olyan esetben, amikor a sorrendben, add meg a elemet, hogy ez nem számít.