C 线程二叉树的有序后继树

我正在编写一个c程序来创建线程二叉树，然后查找特定节点的后续节点。为此，我将显示TBT构造的顺序，然后要求用户输入要显示后续节点的节点。。我写了一个函数来做这个。但是我没有得到第一个节点的继任者。。最后一个节点的后继节点为0，无论以何种方式都可以正常工作。。有人能帮我修一下吗？ 以下是整个计划：

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


struct tbtnode {
       int data;
       struct tbtnode *left,*right;
       int lbit,rbit,flag;
       int child;
}*root=NULL;

typedef struct tbtnode TBT;


TBT *insuc(TBT *t);




void inorder(TBT *);

void create(TBT *);

void create(TBT *root)
{
   int x,op,flag,y;
   flag=0;
   char ch;
   TBT *curr=root;
   TBT *q,*p;
 do
   {

     printf("\nCurrent node %d \n\n 1.Left Direction.\n\n2.Right Direction",curr->data);
     printf("\nEnter ur choice :");
     scanf("%d",&op);
     switch(op)
     {
        case 1: if(curr->lbit==1)
                {
                    printf("Enter left child of %d : ",curr->data);
                    scanf("%d",&x);
                    q=(TBT *)malloc(sizeof(TBT));
                    q->data=x;
                    q->lbit=q->rbit=1;
                    q->left=curr->left;
                    q->right=curr;
                    curr->left=q;
                    curr->lbit=0;
                    q->child=0;
                    flag=1;
                }
                else
                    curr=curr->left;
                break;
        case 2: if(curr->rbit==1)
                {

                    printf("Enter right child of %d :",curr->data);
                    scanf("%d",&x);
                    q=(TBT *)malloc(sizeof(TBT));
                    q->data=x;
                    q->lbit=q->rbit=1;
                    q->left=curr;
                    q->right=curr->right;
                    curr->right=q;
                    curr->rbit=0;
                    q->child=1;
                    flag=1;
                }
                else
                    curr=curr->right;
                break;
    }
  }while(flag==0);
}



void inorder(TBT *head)
   {
    TBT *t;
    t=head->left;
    printf("\n");
    while(t->lbit==0)
    t=t->left;
      while(t!=head)
       {
     printf("  %d",t->data);
     t=insuc(t);
       }
   }

TBT *insuc(TBT *t)
   {
     if(t->rbit==0)
      {
      t=t->right;
       while(t->lbit==0)
      t=t->left;
      return(t);
      }
     else
       return(t->right);
    }


void inorder_successor(TBT *head,int x)
   {
    TBT *t;
    t=head->left;
    printf("\n");
    while(t->lbit==0)
    t=t->left;
      while(t!=head)
       {   
           t=insuc(t);
           if(t->data==x)
           { 
                t=insuc(t);
                printf("  %d",t->data);
            }
       }
   }


int main()
  {

    int op,x,n,i=0,item;
    char ch;
    TBT *head,*root,*succ;       //here head indicates dummy variable

    head=(TBT *)malloc(sizeof(TBT));
    head->left=head;
    head->right=head;
    head->lbit=1;
    head->rbit=1;

      do
      {
     printf("\n****Threaded binary tree operations****");
     printf("\n1)create\n2)inorder\n3)Successor\n4)exit");
     printf("\nEnter ur choice: ");
     scanf("%d",&op);
  switch(op)
   {
    case 1:

    printf("\nEnter Number Of Nodes :");
    scanf("%d",&n);
    printf("\nEnter root data: ");
    scanf("%d",&x);

     root=(TBT *)malloc(sizeof(TBT));
     root->data=x;
     root->lbit=root->rbit=1;
     root->child=0;
     root->left=head->left;

     head->left=root;
     head->lbit=0;
     root->right=head->right;


     for(i=0;i<n-1;i++)
      create(root);

      break;

    case 2:
    printf("\nInorder Traversal Is:\n");
      inorder(head);
      break;

    case 3: printf("Enter the node to which successor is to be found\n");
            scanf("%d",&item);
            inorder_successor(head,item);
            break;
    case 4:
      return(0);
      break;
    }
 }while(op<=4);
return 0;
}

#包括
#包括
结构tbtnode{
int数据；
结构tbtnode*左，*右；
国际lbit、rbit、flag；
智力儿童；
}*root=NULL；
类型定义结构TBT节点TBT；
技术性贸易壁垒*INSOC（技术性贸易壁垒*t）；
订单无效（待定*）；
无效创建（TBT*）；
无效创建（待定*根）
{
int x，op，flag，y；
flag=0；
char ch；
TBT*电流=根；
技术性贸易壁垒*q，*p；
做
{
printf（“\n当前节点%d\n\n 1.左方向。\n\n2.右方向”，当前->数据）；
printf（“\n输入您的选择：”）；
scanf（“%d”和&op）；
开关（op）
{
案例1:if（curr->lbit==1）
{
printf（“输入%d的左子项：”，当前->数据）；
scanf（“%d”和&x）；
q=（TBT*）马洛克（sizeof（TBT））；
q->data=x；
q->lbit=q->rbit=1；
q->左=当前->左；
q->右=当前；
当前->左=q；
curr->lbit=0；
q->child=0；
flag=1；
}
其他的
当前=当前->左侧；
打破
案例2：如果（当前->rbit==1）
{
printf（“输入%d的右子项：”，当前->数据）；
scanf（“%d”和&x）；
q=（TBT*）马洛克（sizeof（TBT））；
q->data=x；
q->lbit=q->rbit=1；
q->左=当前；
q->右=当前->右；
curr->right=q；
当前->rbit=0；
q->child=1；
flag=1；
}
其他的
当前=当前->右侧；
打破
}
}while（flag==0）；
}
订单无效（待定*表头）
{
技术性贸易壁垒*t；
t=头部->左侧；
printf（“\n”）；
而（t->lbit==0）
t=t->左；
while（t！=头）
{
printf（“%d”，t->data）；
t=因苏克（t）；
}
}
技术性贸易壁垒*INSOC（技术性贸易壁垒*t）
{
如果（t->rbit==0）
{
t=t->右；
而（t->lbit==0）
t=t->左；
返回（t）；
}
其他的
返回（t->右）；
}
订单后继者无效（TBT*head，int x）
{
技术性贸易壁垒*t；
t=头部->左侧；
printf（“\n”）；
而（t->lbit==0）
t=t->左；
while（t！=头）
{   
t=因苏克（t）；
如果（t->data==x）
{ 
t=因苏克（t）；
printf（“%d”，t->data）；
}
}
}
int main（）
{
int op，x，n，i=0，项；
char ch；
TBT*head，*root，*succ；//这里head表示伪变量
头=（TBT*）马洛克（尺寸（TBT））；
头部->左侧=头部；
头部->右侧=头部；
头部->lbit=1；
头部->rbit=1；
做
{
printf（“\n****线程化二叉树操作****”）；
printf（“\n1）创建\n2）顺序\n3）后续\n4）退出”）；
printf（“\n输入您的选择：”）；
scanf（“%d”和&op）；
开关（op）
{
案例1：
printf（“\n输入节点数：”）；
scanf（“%d”和“&n”）；
printf（“\n输入根数据：”）；
scanf（“%d”和&x）；
根=（TBT*）malloc（sizeof（TBT））；
根->数据=x；
root->lbit=root->rbit=1；
root->child=0；
根->左=头->左；
头部->左侧=根部；
头部->lbit=0；
根->右=头->右；
对于（i=0；i您的代码有很多问题。首先，您从不检查
NULL
指针。要继续，您在
main
中有一个名为
root
的全局变量和局部变量

最后一件事是，当您在
main
中为
root
分配内存时，您为局部变量分配内存，而全局变量仍然是
NULL

还有一些看起来很奇怪的事情，比如你把
头的
指针分配给它自己

我认为您需要首先在纸上列出所有内容，包括您现在拥有的内容和您想要的内容。这将帮助您更好地可视化树。
在调试器中逐行查看代码。如果您没有发现问题，希望您可以缩小范围，只显示相关代码，而不是所有内容。不幸的是，我就是我们正在运行Mac，我不知道如何在gcc Mac中运行调试器：（
gdb
不能像
gcc
那样安装在Mac上？。@JoachimPileborg，inorder\u succession（）中出错了……它没有为inorder序列的第一个节点提供后续。。