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

你的树似乎不是自我平衡的。 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），但是你需要更少的引用来存储整个东西，缓存性能应该更好。

如果你需要一个可变树，并希望提高效率，你可能需要让它自我平衡，在这种情况下你添加元素的顺序无关紧要。< / p>

Answer 2

如果你有一个自我平衡的二叉搜索树，那么预先对数组进行排序可能会产生反作用。将排序数据最佳地添加到平衡树的算法与添加无序数据的算法完全不同。

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

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

2 个答案: