sort Array před přidáním do binárního vyhledávacího stromu Javě

Question

sort Array před přidáním do binárního vyhledávacího stromu Javě

hlasů

0

Mám pole řetězců, které jsou v pořádku AZ. Říkal jsem si, že nejlepší způsob, jak jít o jejich třídění pro vyváženou binárního vyhledávacího stromu. Moje první myšlenka je rozdělit pole až do první poloviny a druhé poloviny a pak třídit jednotlivě.

Neměl bych být schopen používat rekurzivní způsob, jak udržet rozdělí jej v polovině získat další uzel na stromě? Já prostě nemůžu zabalit hlavu kolem něj právě teď a myslel bych se zeptat, jestli někdo měl nějaké nápady. mě vedou správným směrem, nebo poskytují několik příkladů. Dík!

Já používám svůj vlastní BinaryTree Class a BinaryTreeNode Class. UPRAVIT:

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

by to být považováno za Já vyrovnávací strom binárního vyhledávání?

java recursion binary-search-tree

Položena 07/11/2011 v 09:32
zdroj uživatelem Pengume

V jiných jazycích...

2 odpovědí

hlasů

0

Pokud máte binární vyhledávací strom, který je self-vyvážení je to docela pravděpodobně kontraproduktivní roztřídit pole. Algoritmus pro optimální přidávání seřazené údaje k vyváženému stromu je zcela odlišný od algoritmu pro přidání neuspořádaných dat.

Nicméně není nic ‚self-balancing‘ o kódu, který vyslán. Je to jen obyčejná binární strom vložení algoritmus.

Odpovězeno 07/11/2011 v 09:37
zdroj uživatelem EJP

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

Váš strom se nezdá být samo vyvažování. Samovyvažující BST přijmou opatření, po vložení, nebo po několika vložkami, aby se zajistilo, že je (zhruba) v rovnováze.

Máte-li pouze přidat prvky jednou a použít strom jen čte, máte seřazené pole a pak postupujte takto: vyberte prvek ve středu. vytvořte kořen s ním jako klíč, a pak rekurzivně přidat prvky po jeho levé straně (z menších prvků) jako levého podstromu svého kořene, a prvky, které jeho práva jako pravého podstromu, resp. Ty by měly skončit s BST, který je víceméně vyrovnaná. Příklad číslo:

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

    /* ... */
}

Nicméně, v tomto případě může nechat své prvky v tříděném poli a pomocí binárního vyhledávání na indexu do něj namísto stromu. Vzhledem ke složitosti by měl být stejný, O (LOGN), ale budete potřebovat méně odkazy uložit celou věc, a výkon vyrovnávací paměti by měla být lepší.

Pokud potřebujete mít proměnlivý strom, a chcete, aby to efektivní, měli byste pravděpodobně potřebovat, aby se to self-vyrovnaný, případ, ve kterém pořadí, ve kterém můžete přidat prvky, které na tom nezáleží.