在添加到二叉搜索树 Java 之前对数组进行排序

Question

我有一个按 A-Z 顺序排列的字符串数组。我想知道对它们进行排序以获得平衡二叉搜索树的最佳方法。我最初的想法是将数组分成前半部分和后半部分，然后分别对它们进行排序。

我不应该能够使用递归方式将其分成两半以获得树的下一个节点吗？我现在无法理解它，并想我会问是否有人有任何想法。引导我走向正确的方向或提供一些例子。谢谢！

我正在使用我自己的 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;
 }
 }

这会被认为是自平衡二叉搜索树吗？

Answer 1

如果您有一个自平衡的二叉搜索树，那么对数组进行预排序很可能会适得其反。将排序数据优化添加到平衡树的算法与添加无序数据的算法有很大的不同。

但是，您发布的代码没有任何“自我平衡”。就是一个普通的二叉树插入算法。

Answer 2

你的树似乎没有自我平衡。 self-balancing BST 将在插入后或多次插入后采取措施，以确保（大致）平衡。

如果您只添加一次元素并将树用于读取，则您拥有排序数组，然后按以下步骤操作：选择中间的元素。以它为键创建一个根，然后递归地将其左侧的元素（较小的元素）添加为根的左子树，并将其右侧的元素分别添加为右子树。你最终应该得到一个或多或少平衡的 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)，但是你需要更少的引用来存储整个东西，并且缓存性能应该更好。

如果您需要一棵可变树，并希望使其高效，您可能需要使其自平衡，在这种情况下，您向其中添加元素的顺序并不重要。