代码中的错误说无法将bstNode*转换为bstNode**。我在这里使用双指针的概念以及递归

Question

    #include<stdio.h>
    #include<stdlib.h>


     struct bstNode
     {
     int data;
     struct bstNode *left;
     struct bstNode *right;
     };



     struct bstNode* getNewNode(int data)
     {
     struct bstNode* newNode = (struct bstNode*)malloc(sizeof(struct bstNode));
      newNode->data = data;
     newNode->left = newNode->right = NULL;
     return newNode;
     }

     void Insert(struct bstNode** root, int data)
     {
        if(*root == NULL)
       {
           *root = getNewNode(data);
     }

     else
     if(data >= (*root)->data)
     {
         Insert((*root)->right, data);
     }
     else
     {
         Insert((*root)->left, data);
     }
 }

 void Search(struct bstNode** root,int data)
 {
     if(data == (*root)->data)
     {
         printf("Data Found");
         getchar();
         exit(0);
     }

     else
     if(data >= (*root)->data)
     {
         Search((*root)->left, data);
     }
     else
     {
         Search((*root)->right, data);
     }
 }

 int main()
 {
     struct bstNode* root = NULL;
     Insert(&root,12);
     Insert(&root,13);
     Insert(&root,1);
     Insert(&root,16);
     Insert(&root,8);
     Insert(&root,19);

     Search(&root,8);
     Search(&root,6);

     return 0;
 }

在上面的代码中，我试图将指针变量的地址从主函数传递给Insert函数。据我所知，这里它应该接受作为指针对指针的论点，但它不接受。问题是什么？请帮忙，这样我也可以更新我的知识。非常感谢。

详细错误如下：

main.cpp：在函数'空插入（bstNode**， int）'：main.cpp:32： 37：错误：无法将'bstNode*'转换为'bstNode**'参数'1'到'空插入（bstNode**， int）'插入（（*root）-

main.cpp:36： 36：错误：无法将参数'1'的'bstNode*'转换为'bstNode**'，以'无效插入（bstNode**， int）'插入（*root）-

main.cpp：56：37：错误：无法将参数“1”的“bstNode*”转换为“bstNode**”到“void Search（bstNode**， int）” 搜索（（*根）-

Answer 1

解释

您错过了

但是您发布的代码会导致分段错误，即使在纠正类型错误之后也是如此。这是因为，正如我在评论中提到的，您的程序中存在多个逻辑错误。我在下面列出了它们：

>

您尚未在Search函数中指定递归的终止条件。递归搜索最终导致分段错误。

您在else if和else中递归调用 函数时使用了错误的参数。如果＜code＞数据

虽然不是错误，但当您在 BST 中找到搜索的值时，您正在使用 exit（0）。这将立即终止程序，因此，如果 BST 中存在该值，则只能在主函数中使用一次搜索。

您没有消息指示该值在 BST 中不存在。

我所做的修改包括:

> 搜索

函数中递归搜索的终止条件，即检查为 *root == NULL

交换递归搜索调用的参数。

添加消息以确定该值何时在 BST 中不存在

添加了用于检查BST中不存在的值的注释搜索

下面是修改后的代码的最终工作版本。我建议您去掉< code>exit(0)并用其他机制来代替它。

修改的工作代码

    #include <stdio.h>
    #include <stdlib.h>

    struct bstNode
    {
        int data;
        struct bstNode *left;
        struct bstNode *right;
    };

    struct bstNode *getNewNode(int data)
    {
        struct bstNode *newNode = (struct bstNode *)malloc(sizeof(struct bstNode));
        newNode->data = data;
        newNode->left = newNode->right = NULL;
        return newNode;
    }

    void Insert(struct bstNode **root, int data)
    {
        if (*root == NULL)
        {
            *root = getNewNode(data);
        }

        else if (data >= (*root)->data)
        {
            Insert(&((*root)->right), data);
        }
        else
        {
            Insert(&((*root)->left), data);
        }
    }

    void Search(struct bstNode **root, int data)
    {
        if (*root != NULL)
        {
            if (data == (*root)->data)
            {
                printf("Data Found");
                getchar();
                exit(0);
            }

            else if (data > (*root)->data)
            {
                Search(&((*root)->right), data);
            }
            else
            {
                Search(&((*root)->left), data);
            }
        }
    }

    int main()
    {
        struct bstNode *root = NULL;
        Insert(&root, 12);
        Insert(&root, 13);
        Insert(&root, 1);
        Insert(&root, 16);
        Insert(&root, 8);
        Insert(&root, 19);

        Search(&root, 8);
        // Search(&root, 29);
        printf("Data Not Found");

        return 0;
    }

这是实现相同目标的工作解决方案，不使用双重引用 （**）。

我的解决方案

#include<stdio.h>
#include<stdlib.h>

struct node
{
    int data;
    struct node *left;
    struct node *right;
};

struct node *createNode(value){
    struct node *newNode = malloc(sizeof(struct node));
    newNode->data = value;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}


struct node *insert(struct node *root, int data)
{
    if (root == NULL) return createNode(data);

    if (data < root->data)
        root->left  = insert(root->left, data);

    else if (data > root->data)
        root->right = insert(root->right, data);   

    return root;
}

void search(struct node *root, int data, int *found){
    if(root == NULL) return;

    search(root->left, data, found);

    if(root->data == data){
        *found = 1;
    } 

    search(root->right, data, found);
}

int main(){
    struct node *root = NULL;

    root = insert(root, 8);
    insert(root, 3);
    insert(root, 1);
    insert(root, 6);
    insert(root, 7);
    insert(root, 10);
    insert(root, 14);
    insert(root, 4);

    int found7 = 0, found9 = 0;
    search(root, 7, &found7);
    search(root, 9, &found9);

    found7 ? printf("7 found in BST\n") : printf("7 not found\n");

    found9 ? printf("9 found in BST\n") : printf("9 not found\n");

    return 0;
}

Answer 2

在像这样的函数的if语句中

 if(data >= (*root)->data)
 {
     Insert((*root)->right, data);
 }
 else
 {
     Insert((*root)->left, data);
 }

例如表达式（*root）-

     Insert( &(*root)->right, data);