Java 排序数组中的BST列表

这是我实验室的一个问题，我被难住了。我们基本上得到一个已经排序的数组，我们必须使用这个数组以列表格式创建一个BST。（这看起来怎么样）？以下是我到目前为止的代码，但它根本不起作用，我不知道如何修复它：

    private static void buildBalancedRec(Integer [] tempArr, int start, int end,
        BinarySearchTreeList<Integer> bstList)
{       
    if (bstList.size()<tempArr.length){
        Integer middle  = tempArr[(start+end)/2];
        bstList.add(middle);
        buildBalancedRec(tempArr, start , middle-1 , bstList);
        buildBalancedRec(tempArr, middle+1, end, bstList);
}

因此，我假设列表会是这样的

我怎么去那里？我可以像在当前代码中一样，有两行背靠背的递归代码吗

我尝试了很多方法，但是我永远无法让它打印{4,2,6,1,3,5,7}

任何指导都将不胜感激

注意：该方法需要使用递归

尝试：

private static void buildBalancedRec(int[] tempArr, int start, int end, BinarySearchTreeList<Integer> list) {
    if (start < end) {
        int middle = (start + end) / 2;
        list.add(tempArr[middle]);
        buildBalancedRec(tempArr, start, middle, list);
        buildBalancedRec(tempArr, middle + 1, end, list);
    }
}

---

您可以使用与Day Stout Warren方法类似的方法，该方法将树转换为“vine”（类似于链表），然后从“vine”创建一个平衡树，只有在这种情况下，第一步是将排序数组转换为“vine”

重新平衡BST的示例代码。在这种情况下，需要将排序数组转换为“vine”，然后调用函数vine_to_tree（）。不要忘记启动“vine”的伪节点

//重新平衡二进制搜索树
#包括
#包括
结构节点{
大小值；
节点*p_左；
节点*p_右；
};
节点*插入（节点*p_树，大小\u t值）
{
if（p_树==NULL）{
p_树=新节点；
p_tree->p_left=NULL；
p_tree->p_right=NULL；
p_树->值=值；
}else if（值值）{
p_树->p_左=插入（p_树->p_左，值）；
}否则{
p_树->p_右=插入（p_树->p_右，值）；
}
返回p_树；
}
节点*delete_树（节点*p_树）
{
节点*p_节点；
while（p_树！=NULL）{
if（p_树->p_左！=NULL）{
p_节点=p_树->p_左；
p_树->p_左=p_节点->p_右；
p_节点->p_右=p_树；
p_树=p_节点；
}否则{
p_节点=p_树；
p_树=p_树->p_右；
std：：cout p_right；
尺寸=尺寸+1；
}else{//else向右旋转
p_temp=p_余数->p_左；
p_余数->p_左=p_临时->p_右；
p_temp->p_right=p_余数；
p_剩余=p_温度；
p_vine_tail->p_right=p_temp；
}
}
*p_尺寸=尺寸；
返回p_根；
}
尺寸地板功率（尺寸大小）
{
尺寸n=1；
而（n p_right->p_left=0，p_root->p_right->p_right->p_right->p_left=2
节点*完美叶（节点*p_根、大小\u t叶数、大小\u t大小）
{
node*p_扫描仪；
节点*p_叶；
尺寸i；
尺寸、孔数；
下一个孔的尺寸；
尺寸、孔指数；
叶片位置的尺寸；
如果（叶数=0）
返回p_根；
叶位置=两个（尺寸+1）/2的单元功率；
孔数=叶数位置-叶数；
孔指数=1；
下一个孔=叶位置/孔数；
p_scanner=p_根；
对于（i=1；ip_right；
孔索引=孔索引+1；
下一个孔=（孔索引*叶位置）/孔计数；
}否则{
p_叶=p_扫描器->p_右；
p_扫描器->p_右=p_叶->p_右；
p_scanner=p_scanner->p_right；
p_扫描器->p_左=p_叶；
p_leaf->p_right=NULL；
}
}
返回p_根；
}
//左旋转子树
节点*压缩（节点*p_根，大小\u t计数）
{
node*p_扫描仪；
节点*p_子节点；
尺寸i；
p_scanner=p_根；
对于（i=1；i p_右；
p_扫描器->p_右=p_子->p_右；
p_scanner=p_scanner->p_right；
p_child->p_right=p_scanner->p_left；
p_scanner->p_left=p_child；
}
返回p_根；
}
//把藤蔓变成完美平衡的树
节点*藤到树（节点*根，大小）
{
如果不是整棵树，树叶的大小/数量
叶数=尺寸+1-两层的楼层功率（尺寸+1）；
完美的叶子（根、叶数、大小）；
大小=大小-叶数；
而（大小>1）{
压缩（p_根，大小/2）；
尺寸=尺寸/2；
}
返回p_根；
}
//重新平衡树到完美平衡树
节点*再平衡树（节点*p\U根）
{
节点*p_伪；
大小；
p_pseudo=新节点；
p_pseudo->value=0；
p_pseudo->p_left=NULL；
p_伪->p_右=p_根；
p_pseudo=树到藤（p_pseudo和大小）；
p_pseudo=藤到树（p_pseudo，大小）；
p_根=p_伪->p_右；
删除p_伪；
返回p_根；
}
int main（）
{
节点*p_树=NULL；
尺寸i；
对于（i=0；i<14；i++）
p_树=插入（p_树，i）；
p_树=再平衡树（p_树）；
返回0；
}

我看到一个错误：

整数中间=tempArr[（开始+结束）/2]；bstList.add（中间）；

当它必须是

整数中间=（开始+结束）/2；bstList.add（tempArr[middle]）；

我用你的建议替换了这个错误，但是，最终结果仍然是一样的这打印出的“4,2,6,1,3,5”“但最后7名是missing@needHelp3212345我发布了完整的实现示例，它可以工作，也许您的代码（在类

BinarySearchTreeList

中）或打印机算法中有错误。为了避免溢出问题：

int middle=start+（end-start）/2；

private static void buildBalancedRec(int[] tempArr, int start, int end, BinarySearchTreeList<Integer> list) {
    if (start < end) {
        int middle = (start + end) / 2;
        list.add(tempArr[middle]);
        buildBalancedRec(tempArr, start, middle, list);
        buildBalancedRec(tempArr, middle + 1, end, list);
    }
}

private static void buildBalancedRec(int[] tempArr, int start, int end, List<Integer> list) {
    if (start < end) {
        int middle = (start + end) / 2;
        list.add(tempArr[middle]);
        buildBalancedRec(tempArr, start, middle, list);
        buildBalancedRec(tempArr, middle + 1, end, list);
    }
}

public static void main(String[] args) {
    int[] tempArr = {1, 2, 3, 4, 5, 6, 7};
    List<Integer> list =new ArrayList<>(tempArr.length);
    buildBalancedRec(tempArr, 0, tempArr.length, list);
    System.out.println(list);
}

[4, 2, 1, 3, 6, 5, 7]

//      rebalance binary search tree

#include <iostream>
#include <iomanip>

struct node {
    size_t value;
    node *p_left;
    node *p_right;
};

node *insert (node *p_tree, size_t value)
{
    if (p_tree == NULL) {
        p_tree = new node;
        p_tree->p_left = NULL;
        p_tree->p_right = NULL;
        p_tree->value = value;
    } else if (value < p_tree->value) {
        p_tree->p_left = insert(p_tree->p_left, value);
    } else {
        p_tree->p_right = insert(p_tree->p_right, value);
    }
    return p_tree;
}

node *delete_tree (node *p_tree)
{
node *p_node;
    while(p_tree != NULL){
        if(p_tree->p_left != NULL) {
            p_node = p_tree->p_left;
            p_tree->p_left = p_node->p_right;
            p_node->p_right = p_tree;
            p_tree = p_node;
        } else {
            p_node = p_tree;
            p_tree = p_tree->p_right;
            std::cout << "deleting " << std::setw(2) << p_node->value << std::endl;
            delete p_node;
        }
    }
    return NULL;
}

//  convert tree to vine (list) of p_rights
node * tree_to_vine(node *p_root, size_t *p_size)
{
node * p_vine_tail;
node * p_remainder;
node * p_temp;
size_t size;

    p_vine_tail = p_root;
    p_remainder = p_vine_tail->p_right;
    size = 0;
    while(p_remainder != NULL){
        if(p_remainder->p_left == NULL){    // if left == null, follow right path
            p_vine_tail = p_remainder;
            p_remainder = p_remainder->p_right;
            size = size + 1;
        } else {                            // else rotate right
            p_temp  = p_remainder->p_left;
            p_remainder->p_left = p_temp->p_right;
            p_temp->p_right = p_remainder;
            p_remainder = p_temp;
            p_vine_tail->p_right = p_temp;
        }
    }
    *p_size = size;
    return p_root;
}

size_t floor_power_of_two(size_t size)
{
size_t n = 1;
    while(n <= size)
        n = n + n;
    return n/2;
}

size_t ceil_power_of_two(size_t size)
{
size_t n = 1;
    while(n < size)
        n = n + n;
    return n;
}

// split vine nodes, placing all even (0, 2, 4, ...) leaves on left branches
// p_root->p_right->p_left = 0, p_root->p_right->p_right->p_left = 2

node * perfect_leaves(node * p_root, size_t leaf_count, size_t size)
{
node *p_scanner;
node *p_leaf;
size_t i;
size_t hole_count;
size_t next_hole;
size_t hole_index;
size_t leaf_positions;

    if(leaf_count == 0)
        return p_root;
    leaf_positions = ceil_power_of_two(size+1)/2;
    hole_count = leaf_positions - leaf_count;
    hole_index = 1;
    next_hole = leaf_positions / hole_count;
    p_scanner = p_root;
    for(i = 1; i < leaf_positions; i += 1){
        if(i == next_hole){
            p_scanner = p_scanner->p_right;
            hole_index = hole_index + 1;
            next_hole = (hole_index * leaf_positions) / hole_count;
        } else {
            p_leaf = p_scanner->p_right;
            p_scanner->p_right = p_leaf->p_right;
            p_scanner = p_scanner->p_right;
            p_scanner->p_left = p_leaf;
            p_leaf->p_right = NULL;
        }
    }
    return p_root;
}

//  left rotate sub-tree
node * compression(node * p_root, size_t count)
{
node *p_scanner;
node *p_child;
size_t i;
    p_scanner = p_root;
    for(i = 1; i <= count; i += 1){
        p_child = p_scanner->p_right;
        p_scanner->p_right = p_child->p_right;
        p_scanner = p_scanner->p_right;
        p_child->p_right = p_scanner->p_left;
        p_scanner->p_left = p_child;
    }
    return p_root;
}

//  convert vine to perfect balanced tree
node * vine_to_tree(node *p_root, size_t size)
{
size_t leaf_count; // # of leaves if not full tree
    leaf_count = size + 1 - floor_power_of_two(size+1);
    perfect_leaves(p_root, leaf_count, size);
    size = size - leaf_count;
    while(size > 1){
        compression(p_root, size / 2);
        size = size / 2;
    }
    return p_root;
}

//  reblance tree to perfect balanced tree
node * rebalance_tree(node *p_root)
{
node * p_pseudo;
size_t size;
    p_pseudo = new node;
    p_pseudo->value = 0;
    p_pseudo->p_left = NULL;
    p_pseudo->p_right = p_root;
    p_pseudo = tree_to_vine(p_pseudo, &size);
    p_pseudo = vine_to_tree(p_pseudo, size);
    p_root = p_pseudo->p_right;
    delete p_pseudo;
    return p_root;
}

int main()
{
node *p_tree = NULL;
size_t i;
    for(i = 0; i < 14; i++)
        p_tree = insert(p_tree, i);
    p_tree = rebalance_tree(p_tree);
    return 0;
}