C++ 二叉树中的无限循环

这是一个用于构建二叉树的函数，其中的参数是整数列表（list）和要写入树的空向量（tree）。我确信这是一个非常简单的错误，但出于某种原因，我忽略了是什么导致了这个循环。谢谢你的帮助

void buildTree(vector<int> list, vector<int> tree)
{
    for(int i=0; i<list.size(); i++)
    {
    bool placed = false;
    int source = 1;

        while(!placed)
        {
            if(tree[source] == NULL)
            {
                tree[source] = list[i];
                placed = true;
            }
            else if(list[i] < source)
            {
                source = 2*source;
            }

            else if(list[i] > source)
            {
                source = 2*source+1;
            }
        }
    }
}

void构建树（向量列表，向量树）
{
对于（int i=0；i源）
{
震源=2*震源+1；
}
}
}
}

让我们假设

列表[0]

为1，

树[1]

不为空。在这种情况下，while循环将无限执行，因为如果满足条件，则树中没有一个

。
您的比较，
list[i]
和
list[i]>source
应该是
list[i]和
list[i]>tree[source]
。现在，您正在将尝试插入的值与树向量的索引进行比较。
问题是您正在将值（即
list[i]
）与索引（即
source
）进行比较，而不是使用
tree[source]
：

else if(list[i] < tree[source])
{
    source = 2*source;
}
else if(list[i] > tree[source])
{
    source = 2*source+1;
}

您的代码存在一些问题：

-您正在按值接收向量，在对函数的所有调用中，向量都将被复制，因此，在函数外部，您无法访问写入的
向量树
，并支付性能损失。

-我假设您使用的是一个空树（如果没有擦除行
if（tree.size（）
。这是因为无法预测表示树的向量的大小，这取决于列表中的元素。这可以通过分配避免多次连续分配所需的更多空间来增强，例如：分配
源*因子
（因子>1.0），而不是像向量那样分配
源


-您正在将列表元素与
树的索引进行比较
：
否则，如果（list[i]
，则此比较需要与值进行比较。

void buildTree(const vector<int>& list, vector<int>& tree) {
    for (int i = 0; i < list.size(); i++) {
        bool placed = false;
        int source = 1;
        while (!placed) {
            if (tree.size() < source) {
                tree.resize(source);
            }

            if (tree[source - 1] == 0) {
                tree[source - 1] = list[i];
                placed = true;
            } else if (list[i] < tree[source - 1]) {
                source = 2 * source;
            } else if (list[i] > tree[source - 1]) {
                source = 2 * source + 1;
            }
        }
    }
}

std::vector<int> tree;
buildTree(std::vector<int>{5, 2, 4, 13, 8, 25, 32}, tree);

void构建树（常量向量和列表、向量和树）{
对于（int i=0；i树[source-1]）{
震源=2*震源+1；
}
}
}
}
向量树；
构建树（std：：向量{5,2,4,13,8,25,32}，树）；
您的逻辑似乎有误。您正在将“列表项”与“索引源”进行比较

如果您试图构造“二进制堆”，从结果树中没有元素开始，

代码可能很复杂

相反，尝试将列表复制到树中，然后使用

Heapify logic.
我想
放置的
永远不会变成
真的
。我想说的是，我喜欢你的代码有一个
向量
命名为
列表
。请不要用
列表
之类的STL单词作为变量名。这很混乱。你从来没有测试过
列表[I]==source
。这是故意的吗？另一个问题是，您的
树
是按值传递的。当该函数返回时，您传递的
树
不会更改。按引用传递
树
，而不是按值传递。
void buildTree(const vector<int>& list, vector<int>& tree) {
    for (int i = 0; i < list.size(); i++) {
        bool placed = false;
        int source = 1;
        while (!placed) {
            if (tree.size() < source) {
                tree.resize(source);
            }

            if (tree[source - 1] == 0) {
                tree[source - 1] = list[i];
                placed = true;
            } else if (list[i] < tree[source - 1]) {
                source = 2 * source;
            } else if (list[i] > tree[source - 1]) {
                source = 2 * source + 1;
            }
        }
    }
}

std::vector<int> tree;
buildTree(std::vector<int>{5, 2, 4, 13, 8, 25, 32}, tree);