C 破解老师的伪代码有困难吗

我正在为类做一个二进制搜索树赋值，对于这个函数，我需要遵循我教授的伪代码。不幸的是，我不确定一个具体的细节，她拒绝澄清

伪代码的链接如下：

---

我希望输出将值添加到二元搜索树并返回true，但当前程序只是在我到达需要“node”的部分时抛出一个错误。正如您所提到的，这是一个在二元搜索树中插入节点的函数。参数如下所示

parent

是正在检查的节点的父节点。这将通过树的根调用

current

是正在检查的父节点的左侧或右侧。第一次调用函数时，如果当前节点的值小于root，则应使用

root->left

；如果值大于

root

，则应使用

root->right

。如果

root

为空，则

current

也应为

null

if (root == NULL)
{
    ret = recursiveInsert(NULL, NULL, node);
} 
else if (root->value < node->value)     
{
    ret = recursiveInsert(root->left, root, node);
}
else if (root-> value > node->value)
{
    ret = recursiveInsert(root->right, root, node);
}
else 
{
    //same value, handle error
}

似乎

node->value

是整数类型

考虑到所有这些因素，更新后的代码如下

Node* root = NULL;  //global variable
...
bool recursiveInsert(Node* current, Node* parent, Node* node)
{

    if (current == NULL)
    {
        if (parent == NULL)
        {
            root = node;
        }
        else
        {
            if (current->value < parent->value)
            {
                parent->left = node;
            }
            else
            {
                parent->right = node;
            }
            return true;
        }
    }
    else if(node->value == current->value)
    {
        return false;
    }
    else if (parent->value < current->value)
    {
        recursiveInsert(current->left, current, node);
    }
    else
    {
        recursiveInsert(current->right, current, node);
    }   
}

节点*root=NULL//全局变量
...
布尔递归插入（节点*当前，节点*父节点，节点*节点）
{
如果（当前==NULL）
{
如果（父项==NULL）
{
根=节点；
}
其他的
{
如果（当前->值<父->值）
{
父->左=节点；
}
其他的
{
父->右=节点；
}
返回true；
}
}
else if（节点->值==当前->值）
{
返回false；
}
else if（父级->值<当前->值）
{
递归插入（当前->左侧，当前，节点）；
}
其他的
{
递归插入（当前->右侧，当前，节点）；
}   
}

正如您所提到的，这是一个在二进制搜索树中插入节点的函数。参数如下所示

parent

是正在检查的节点的父节点。这将通过树的根调用

current

是正在检查的父节点的左侧或右侧。第一次调用函数时，如果当前节点的值小于root，则应使用

root->left

；如果值大于

root

，则应使用

root->right

。如果

root

为空，则

current

也应为

null

if (root == NULL)
{
    ret = recursiveInsert(NULL, NULL, node);
} 
else if (root->value < node->value)     
{
    ret = recursiveInsert(root->left, root, node);
}
else if (root-> value > node->value)
{
    ret = recursiveInsert(root->right, root, node);
}
else 
{
    //same value, handle error
}

似乎

node->value

是整数类型

考虑到所有这些因素，更新后的代码如下

Node* root = NULL;  //global variable
...
bool recursiveInsert(Node* current, Node* parent, Node* node)
{

    if (current == NULL)
    {
        if (parent == NULL)
        {
            root = node;
        }
        else
        {
            if (current->value < parent->value)
            {
                parent->left = node;
            }
            else
            {
                parent->right = node;
            }
            return true;
        }
    }
    else if(node->value == current->value)
    {
        return false;
    }
    else if (parent->value < current->value)
    {
        recursiveInsert(current->left, current, node);
    }
    else
    {
        recursiveInsert(current->right, current, node);
    }   
}

节点*root=NULL//全局变量
...
布尔递归插入（节点*当前，节点*父节点，节点*节点）
{
如果（当前==NULL）
{
如果（父项==NULL）
{
根=节点；
}
其他的
{
如果（当前->值<父->值）
{
父->左=节点；
}
其他的
{
父->右=节点；
}
返回true；
}
}
else if（节点->值==当前->值）
{
返回false；
}
else if（父级->值<当前->值）
{
递归插入（当前->左侧，当前，节点）；
}
其他的
{
递归插入（当前->右侧，当前，节点）；
}   
}

伪代码上下文中的节点

是先前分配的节点，包含插入到树中的数据。最初的调用者分配它（这是毫无意义的，在RW代码中从来没有这样做过）。实际上，除非您考虑一个可能将节点从一棵树移动到另一棵树的库，并且您希望避免设置/拆除节点本身的费用，否则实际上不太可能执行此模式

关于算法，它相当简单，但不是很漂亮：

如果

current

和

parent

都为空，则表示这必须是树中由某个全局指针

root

跟踪的第一个节点。因此，

root

被直接分配到传入节点

否则，如果

current

为空，但

parent

不为空，则表示

parent

是树中的某个潜在叶（意味着它有一个左指针、一个右指针或两个包含的指针都为空），并且您已到达空指针。插入需要与父值进行比较，以了解是将节点挂起在左侧还是右侧。请注意，这是低效的，因为您已经进行了此比较（这是您如何首先到达这里的）

否则，如果

current

不为空，我们只需检查值是否相等或更小（如果两个值都不为真，则假定值更大），并在保证的情况下进入左或右的子树。在这种情况下，

current.left

或

current.right

成为递归的

current

，并且

current

成为所述相同递归调用的

父调用

就这样。这就是算法的工作原理。坦率地说，这是边缘化的

要使用参数列表实现此算法（最终参数采用值而不是节点），只需确保节点分配仅在实际挂起时发生，然后仅（有两种情况）

bool recursiveInsert(Node* current, Node* parent, double value)
{
    bool result = false;

    if (current == NULL)
    {
        if (parent == NULL)
        {
            root = malloc(sizeof *root);
            root->value = value;
            root->left = root->right = NULL;
        }
        else
        {
            Node *p = malloc(sizeof *p);
            p->value = value;
            p->left = p->right = NULL;

            if (value < parent->value)
            {
                parent->left = p;
            }
            else
            {
                parent->right = p;
            }
            result = true;
        }
    }
    else if (value < parent->value)
        result = recursiveInsert(current->left, current, value);

    else if (parent->value < value)
        result = recursiveInsert(current->right, current, value);

    return result;
}

它并不漂亮，但却很有效。它依赖于全局

根
存在可能是该算法最糟糕的部分。多重比较可能是第二个讨厌的地方


另一种方法
理想情况下，树的根作为参数传入。此外，我们可以使算法像现在一样递归，但不再依赖于某些参数
bool recursiveInsert(Node* current, Node* parent, double value)
{
    bool result = false;

    if (current == NULL)
    {
        if (parent == NULL)
        {
            root = malloc(sizeof *root);
            root->value = value;
            root->left = root->right = NULL;
        }
        else
        {
            Node *p = malloc(sizeof *p);
            p->value = value;
            p->left = p->right = NULL;

            if (value < parent->value)
            {
                parent->left = p;
            }
            else
            {
                parent->right = p;
            }
            result = true;
        }
    }
    else if (value < parent->value)
        result = recursiveInsert(current->left, current, value);

    else if (parent->value < value)
        result = recursiveInsert(current->right, current, value);

    return result;
}

recursiveInsert(root, NULL, value);

bool treeInsert(Node **pp, double value)
{
    bool result = false;
    if (!*pp)
    {
        *pp = malloc(sizeof **pp);
        (*pp)->value = value;
        (*pp)->left = (*pp)->right = NULL;
        result = true;
    }
    else if (value < (*pp)->value)
    {
        result = recursiveInsert(&(*pp)->left, value);
    }
    else if ((*pp)->value < value)
    {
        result = recursiveInsert(&(*pp)->right, value);
    }
    return result;
}

bool treeInsert(Node **pp, double value)
{
    bool result = false;

    while (*pp)
    {
        if (value < (*pp)->value)
            pp = &(*pp)->left;

        else if ((*pp)->value < value)
            pp = &(*pp)->right;

        else break;
    }

    if (!*pp)
    {
        *pp = malloc(sizeof **pp);
        (*pp)->value = value;
        (*pp)->left = (*pp)->right = NULL;
        result = true;
    }

    return result;
}

treeInsert(&root, value);