C 二叉搜索树中的分段错误问题

我必须为排序字符串的赋值创建一个二进制搜索树。我运行了调试模式，发现了分段错误的问题所在，但我不知道问题是什么，也不知道如何修复它。我明白了

#在testbst.c:38处插入0 0x000000000040969（节点=0x7fffffffe008，数据=0x7fffffffe010“运行\n”，c_标志=0）

#testbst.c:156“处主（argc=1，argv=0x7fffffffe188）中的1 0x0000000000400df8

#包括
#包括
#包括
类型定义结构树节点
{
字符*数据；
整数计数；
结构树节点*左；
结构树节点*右侧；
}三烯醇；
空插入（树节点**节点，字符*数据，int c_标志）
{
if（node==NULL）
{
treeNode*温度；
temp=（treeNode*）malloc（sizeof（treeNode））；
温度->数据=数据；
printf（“%sdata”，数据）；
printf（“\n%stemp”，临时->数据）；
temp->left=NULL；
temp->right=NULL；
*节点=温度；
返回；
}
如果（c_标志==1）
{
if（caseCompare（（*节点）->数据，数据）==1）
插入（&（*节点）->左侧，数据，c_标志）；
if（caseCompare（（*节点）->data，data）=-1）
插入（&（*节点）->右侧，数据，c_标志）；
其他的
（*节点）->count++；
}
else if（比较（（*节点）->数据，数据）==1）
插入（&（*节点）->左侧，数据，c_标志）；
if（比较（（*节点）->数据，数据）=-1）
插入（&（*节点）->右侧，数据，c_标志）；
其他的
（*节点）->count++；
}
无效打印顺序（treeNode*节点）
{
if（node==NULL）
{
返回；
}
打印顺序（节点->左侧）；
printf（“%d”，节点->数据）；
打印顺序（节点->右侧）；
}
void DeletePostorder（treeNode*节点）
{
如果（节点！=NULL）
{
DeletePostorder（节点->左侧）；
DeletePostorder（节点->右侧）；
如果（节点->左！=NULL）
自由（节点->左）；
如果（节点->右侧！=NULL）
自由（节点->右侧）；
自由（节点）；
}
}
int比较（char*string1，char*string2）
{
int str1=strlen（string1）；
int str2=strlen（string2）；
int更大；
int i=0；
如果（str1>str2）
更大=str1；
如果（str1tolower（string1[i]））
return 1；//如果字符串1是更远的字母，则返回1
如果（tolower（string1[i]）str2）
更大=str1；
如果（str1string1[i]）
return 1；//如果字符串1是更远的字母，则返回1
if（string1[i]1）
{
printf（“输入错误\n%s\n”，用法）；
出口（0）；
}
如果（argv[optind]！=NULL）
if（（infle=fopen（argv[optind]，“r”））==NULL）
{
printf（“文件\%s\”不存在\n请在您的句子中键入”，argv[optind]）；
infle=stdin；
}
while（fgets（string，sizeof（string），infle）！=NULL&&string[0]！='\n'）
{   
printf（“%s”，字符串）；
插入（&树、字符串、cflag）；
}
打印顺序（树）；
删除后序（树）；
}

if（node==NULL）

在该块之后，函数引用

node

。在哪里设置

node

？1）

if（node==NULL）{..*node=temp；return；}

2）

插入（&tree，string，cflag）；

使用相同的缓冲区（

string

）.3）

空闲（tree）

Free'd only root.

temp->data=data；

不复制数据。这意味着所有节点都指向相同的

字符串
缓冲区。缓冲区本身不会崩溃，但会导致错误的数据。可能导致崩溃的原因是：
if（str1>str2）
和
if（str1
.No
=
大小写。这意味着当两个字符串长度相等时，
更大的
没有设置，并且有一个垃圾值（由于第一个错误，您总是这样）。是的，当存在bug时，往往会有不止一个bug。不幸的是，我们无法为您调试所有bug。如果您学会了更有效的调试方法，这将是最好的选择—从长远来看，这将比支付自己的成本更高。7）
DeletePostOrder
键入为
DeletePostOrder
if（node==NULL）
。在该块之后，函数引用
节点
。如果（node==NULL）{….*node=temp；return；}

2）

插入（&tree，string，cflag）；

使用相同的缓冲区（

string

）插入该节点，则将

设置在何处。3）
空闲（tree）
Free'd only root.
temp->data=data；
不复制数据。这意味着所有节点都指向相同的
字符串
缓冲区。缓冲区本身不会崩溃，但会导致错误的数据。可能导致崩溃的原因是：
if（str1>str2）
和
if（str1
.No
==
大小写。这意味着当两个字符串长度相等时，
更大的
没有设置，并且有一个垃圾值（由于第一个错误，这对您来说总是如此）。是的，当出现错误时
#include<stdio.h>
#include<stdlib.h>
#include <string.h>

typedef struct treeNode
{
    char *data;
    int count;
    struct treeNode *left;
    struct treeNode *right;

} treeNode;


void Insert(treeNode** node,char* data,int c_flag)
{
    if(node==NULL)
    {
        treeNode *temp;
        temp = (treeNode *)malloc(sizeof(treeNode));
        temp -> data = data;
        printf("%sdata", data);
        printf("\n%stemp", temp -> data);
        temp -> left = NULL;
        temp -> right = NULL;
        *node = temp;
        return;
    }
    
    if(c_flag == 1)
    {
        if(caseCompare((*node)->data, data) == 1)
            Insert(&(*node)->left, data, c_flag);
        if(caseCompare((*node)->data, data) == -1)
            Insert(&(*node)->right, data, c_flag);
        else
            (*node)->count++;
    }
    
    else if(compare((*node)->data, data) == 1)
        Insert(&(*node)->left, data, c_flag);
    if(compare((*node)->data, data) == -1)
        Insert(&(*node)->right, data, c_flag);
    else
        (*node)->count++;
}

void PrintInorder(treeNode *node)
{
    if(node==NULL)
    {
            return;
    }
    PrintInorder(node->left);
    printf("%d ",node->data);
    PrintInorder(node->right);
}

void DeletePostorder(treeNode *node)
{
    if(node != NULL)
    {
        DeletePostorder(node->left);
        DeletePostorder(node->right);
        if(node->left!=NULL)
            free(node->left);
        if(node->right != NULL)
            free(node->right);
        free(node);
    }
}

int compare(char* string1, char* string2)
{
   int str1 = strlen(string1);
   int str2 = strlen(string2);
   int bigger;
   int i = 0;

   if(str1 > str2)
        bigger = str1;
   if(str1 < str2)
        bigger = str2;
   for(i = 0; i < bigger; i++)
{
    if(tolower(string1[i]) > tolower(string1[i]))
        return 1; //returns 1 if string 1 is farther letter
    if(tolower(string1[i]) < tolower(string2[i]))
        return -1; //returns -1 if string 1 letter is behind
}
return 0; //returns 0 if same words
}

int caseCompare(char* string1, char* string2)
{
  int str1 = strlen(string1);
  int str2 = strlen(string2);
  int bigger;
  int i = 0;

  if(str1 > str2)
    bigger = str1;
  if(str1 < str2)
    bigger = str2;
for(i = 0; i < bigger; i++)
{
    if(string1[i] > string1[i])
        return 1; //returns 1 if string 1 is farther letter
    if(string1[i] < string2[i])
        return -1; //returns -1 if string 1 letter is behind
}
return 0; //returns 0 if same words
}

int main(int argc, char **argv)
{
extern char *optarg;
extern int optind;
FILE* infile = stdin;
FILE* outfile = stdout;
char string[100];
treeNode* tree = NULL;
int cflag = 0, oflag = 0, c, err;
static char usage[] = "usage: %s [-c] [-o output_file_name] [input_file_filename]\n";

while ((c = getopt(argc, argv, "co:")) != -1)
    switch (c) 
    {
        case 'c':
            cflag  = 1;
            break;
        case 'o':
            oflag = 1;
            outfile = fopen(optarg, "w");
            break; 
        case '?':
            err = 1;
            printf("%s\n", usage);
            break;
    }
    
if((argc - optind) > 1)
{
    printf("Input Incorrect \n%s\n", usage);
    exit(0);
}

if(argv[optind] != NULL)
    if((infile = fopen(argv[optind], "r")) == NULL) 
    {
        printf("File \"%s\" does not exist\nType in your sentences\n", argv[optind]);
        infile = stdin;
    }

while(fgets(string, sizeof(string), infile) != NULL && string[0] != '\n')
{   
    printf("%s", string);
    Insert(&tree, string, cflag);
}
PrintInorder(tree);
DeletePostOrder(tree);

}