сортировать массив перед добавлением в бинарное дерево поиска Java

Question

сортировать массив перед добавлением в бинарное дерево поиска Java

голоса

0

У меня есть массив строк, которые в порядке AZ. Мне было интересно, что лучший способ идти о сортировке их для сбалансированного двоичного дерева поиска. Моя первая мысль, чтобы разделить массив вверх в первую половину и вторую половину, а затем отсортировать их по отдельности.

Разве я не должен быть в состоянии использовать рекурсивный способ сохранить разделив ее пополам, чтобы получить следующий узел для дерева? Я просто не могу обернуть мою голову вокруг него прямо сейчас, и думал, что я хотел бы спросить, если кто имел какие-либо идеи. чтобы привести меня в правильном направлении или привести несколько примеров. Благодаря!

Я использую мой собственный BinaryTree класса и BinaryTreeNode класса. РЕДАКТИРОВАТЬ:

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

будет ли это считаться самобалансировани дерево двоичного поиска?

java recursion binary-search-tree

Задан 07/11/2011 в 09:32
источник пользователем Pengume

На других языках...

2 ответов

голоса

0

Если у вас есть бинарное дерево поиска, которое самобалансировка это вполне вероятно, контрпродуктивно предварительно сортировка массива. Алгоритм оптимального добавления отсортированных данных в сбалансированное дерево довольно сильно отличается от алгоритма для добавления неупорядоченных данных.

Однако нет ничего «самобалансирующийся» о коде публикуемой. Это просто обычный двоичный алгоритм вставки дерева.

Ответил 07/11/2011 в 09:37
источник пользователем EJP

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

Ваше дерево , кажется, не быть самостоятельной балансировкой. Самобалансировку БСТ предпримет шаги, после вставки, или после того, как ряд вставок, чтобы гарантировать , что это (примерно) сбалансированы.

Если вы только добавить элементы один раз и использовать дерево только для чтения, у вас есть отсортированный массив, а затем выполните следующие действия: выберите элемент в середине. создать корень с ним в качестве ключа, а затем рекурсивно добавить элементы слева от него (мелких элементов) в качестве левого поддерева вашего корня и элементы его вправо, правого поддерева, соответственно. Вы должны в конечном итоге с BST, что это более или менее сбалансированным. Пример кода:

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

    /* ... */
}

Однако, в этом случае, вы можете просто сохранить свои элементы в отсортированном массиве, и использовать бинарный поиск по индексу в него, а не из дерева. Сложность должна быть такой же, O (LogN), но вам нужно меньше ссылок, чтобы сохранить все это, и производительность кэш должен быть лучше.

Если вам нужно иметь изменяемое дерево, и хотят, чтобы сделать его эффективным, вы, вероятно, нужно сделать это самоуравновешенным, случаем, в котором порядок, в котором вы добавляете свои элементы, это не имеет значения.