Как вы упомянули, это функция для вставки узла в двоичное дерево поиска. Параметры следующие

1. parent — родитель исследуемого узла. Это будет вызвано с корень дерева.

2. current — слева или справа от исследуемого родительского узла. При первом вызове функции следует использовать root->left, если значение текущего узла меньше корня, или root->right, если значение больше root. Если 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
   }
   

3. node — это новый узел, который нужно добавить в дерево. Выделение памяти для этого узла должно быть выполнено до вызова recursiveinsert, и значение должно быть указано.

Теперь давайте посмотрим на код, который вы написали.

Первая ошибка — использовать третий параметр как double. Это должен быть параметр типа node, который уже должен быть выделен ранее.

Из условия проверьте, что

ELSE IF node.value = current.=value
    RETURN false

кажется, что 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);
    }   
}

node в контексте псевдокода — ранее выделенный узел, содержащий вставляемые в дерево данные. Первоначальный вызывающий объект выделяет его (что бессмысленно и никогда не делается в коде RW). В действительности крайне маловероятно, что на самом деле будет реализован этот шаблон, если только вы не рассматриваете библиотеку, которая потенциально движется узлов из одного дерева в другое, и вы хотите избежать затрат на установку/демонтаж самих узлов.

Что касается алгоритма, он довольно прост, хотя и не очень красив:

1. Если и current, и parent равны нулю, это означает, что это должен быть первый узел в дереве, отслеживаемый некоторым глобальным указателем root. Следовательно, root назначается непосредственно входящему узлу.

2. В противном случае, если current равно нулю, но parent равно нет, если означает, что parent является некоторым потенциальным листом в дереве (это означает, что у него есть левый, правый или оба содержащихся указателя, которые равны нулю), и вы приземлились на нулевой указатель. Вставка требует сравнения с родительским значением, чтобы узнать, повесили ли вы узел слева или справа. Обратите внимание, что это неэффективно, так как вы уже сделали это сравнение (в первую очередь, как вы сюда попали).

3. В противном случае, если current не является нулевым, мы просто проверяем, равны ли значения или меньше (предполагается большее, если ни одно из них не верно), и входим в поддерево слева или справа, если это оправдано. В этом случае current.left или current.right становятся рекурсивными current, а current становятся parent того же самого рекурсивного вызова.

Вот и все. Так работает этот алгоритм. И, честно говоря, это маргинал.

Чтобы реализовать этот алгоритм с вашим списком аргументов (который принимает значение, а не узел в качестве последнего аргумента), вам нужно только убедиться, что выделение узла происходит только тогда, когда пришло время его фактически повесить, а затем Только (есть два таких случая.

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);

Это некрасиво, но это работает. То, что он полагается на глобальное root присутствие, вероятно, является худшей частью этого алгоритма. Множественное сравнение, вероятно, второе в списке гадостей.

Другой подход

В идеале корень дерева передается в качестве аргумента. Далее, мы можем сделать алгоритм рекурсивным, как сейчас, но больше не полагаться на какие-то глобальные root. Наконец, мы можем сократить количество аргументов до двух: адрес указателя (изначально адрес корневого указателя) и вставляемое значение. использование указателя на указатель, поскольку метод доступа к дереву делает этот алгоритм элегантным, независимо от того, используется ли рекурсия или нет. Оба представлены ниже:

Рекурсивная вставка

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);

Любая функция выполнит поставленную задачу. Я оставляю защиту от ошибок как задачу для вас (проверьте свои mallocs).