C语言和有关二叉树层次遍历的问题

谁能帮忙看看这段代码有什么不对吗？是关于循环队列和和层序遍历劫，已经改动好多遍了，还是错误，大多是编译错误

函数接口定义：
void LevelorderTraversal( BinTree BT );
其中BinTree结构定义如下：
typedef struct TNode *Position;
typedef Position BinTree;
struct TNode{
    ElementType Data;
    BinTree Left;
    BinTree Right;
};

typedef enum {false,true} bool;
typedef struct QNode *Queue;
struct QNode{
        char *Data;
        int f;
        int r;
        //int Max;
};
Queue CreatQueue(){
    Queue Q=(Queue)malloc(sizeof(struct QNode));
    Q->Data=(char *)malloc(Max*sizeof(char));
    Q->f=Q->r=0;
    //Q->Max=Max;
    return Q;
}
bool AddQ(Queue Q,int X){
    if((Q->r+1)%Q->Max==Q->f)
        return false;
    else{
        Q->r=(Q->r+1)%Q->Max;
        Q->Data[Q->r]=X;
        return true;
    }

}
bool DeleteQ(Queue Q){
    if(Q->r == Q->f){
        //printf("invalid\n");
        return false;
    }else{
         Q->f=(Q->f+1)%Q->Max;
         return true;
    }
}
void LevelorderTraversal( BinTree BT ){
    Queue Q;
    BinTree T;
    if(!BT) return;
    CreatQueue(Q);
    AddQ(Q,BT);
    while(!Q){
        T=DeleteQ(Q);
        printf("%d",T->Data);
        if(T->Left){
            AddQ(Q,T->Left);
        }
        if(T->Right){
            AddQ(Q,T->Right);
        }
    }
}

• 这有个类似的问题, 你可以参考下: https://ask.csdn.net/questions/7603421
• 这篇博客你也可以参考下：C 编写一个C程序，要求采用模块化设计思想，将相关功能用函数实现，并提供菜单选项，每次程序运行结束后需通过功能0退出程序。该程序具有以下功能：
• 除此之外, 这篇博客: C语言基本栈操作之字符串数字分隔与求数据的个数和最值中的 要求编写一个函数，将整数字符串分割到一个字符串链表中，然后将字符串链表中存储的整数串转换成整数，存储到一连续的存储空间中，最后输出整数的个数及最大数和最小数。 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
  

• 代码：

  #include<stdio.h>
  #include<stdlib.h>
  #include <time.h>
  #include <string.h>
  #define MAXSIZE 20
  //从键盘输入一行以“，”分隔的一组整数，求数据的个数，数据的最大值，最小值，并输出。
  //要求编写一个函数，将整数字符串分割到一个字符串链表中，然后将字符串链表中存储的整数串转换成整数，
  //存储到一连续的存储空间中，最后输出整数的个数及最大数和最小数。
  //d = atof(op); //不是运算符，就肯定是因数了。所以，用atof函数，将字符串转换为double类型/浮点数   
  
  typedef struct node {		//定义栈结构
  	char data;		// 队列元素类型为char 
  	struct node *next;
  }Stack;
  
  char *Input(char item[MAXSIZE]);  //输入字符数字元素
  double *String_Deal(char item[MAXSIZE], Stack **str); //整数字符串分割到一个字符串链表中，然后将字符串链表中存储的整数串转换成整数										 
  void Init_Stack(Stack **s);//建立栈空间，初始化栈
  Stack *Push_Stack(Stack **top, char x);  //入栈
  Stack *Pop_Stack(Stack **top, char x);  //出栈
  void *Output_Stack(Stack *num);  //输出栈元素
  char *Input(char item[MAXSIZE]);  //输入字符数字元素,存放到数组
  void Prt(double figure[]);  //数字元素遍历,求数据的个数，数据的最大值，最小值，并输出
  
  void main()
  {
  	char arr[MAXSIZE] = {0};  //存放输入的原始字符串
  	Stack *number;   //存放分割后的字符串链表
  	double figure[MAXSIZE];  //用数组存放转换后的数字
  	Input(arr);  //输入字符数字元素
  	Init_Stack(&number);
  	String_Deal(arr, &number);
  	Output_Stack(number);//输出分隔后栈内字符元素
  	//figure[MAXSIZE] = *String_Deal(arr, &number);
  	//Prt(figure); //数字元素遍历,求数据的个数，数据的最大值，最小值，并输出
  }
  
  //整数字符串分割到一个字符串链表中，然后将字符串链表中存储的整数串转换成整数
  double *String_Deal(char item[MAXSIZE], Stack **result)//item为输入的字符串
  {
  	char *buf = item; //声明buf saveptr两个变量，是strtok_r函数的需要。  
  	char *saveptr = NULL;
  	char *op; //分隔后的每个字符数字或字符符号 
  	Stack *p;  //p指向入栈后的数字字符
  	double ss;
  	//当strtok()在参数buf的字符串中发现参数","中包涵的分割字符时,则会将该字符改为\0 字符。
  	//在第一次调用时，strtok()必需给予参数buf字符串，往后的调用则将分割后的字符参数saveptr设置成buf。
  	//每次调用成功则返回指向被分割出片段的指针。
  		while ((op = strtok_s(buf, ",", &saveptr)) != NULL) //利用strtok_s函数分隔字符串
  	{
  		if (op != NULL)
  		{
  			Push_Stack(result, *op);//数字字符存入栈
  			buf = saveptr;
  		}
  	}
  	printf("字符分隔并进栈成功！正在将字符串链表中存储的整数串转换成整数......\n");
  	p = *result;
  	int j = 0;  //存放数字数组下标,从0开始存放数据
  	double figure[MAXSIZE];
  	while (p->next )
  	{
  		if (p->data >= '0'&&p->data <= '9')
  		{
  			ss = atof(&(p->data));//字符转为浮点数
  			figure[j] = ss;
  			j++;
  			p = p->next;
  			printf("figure[%d]=%3.6f\n", j, figure[j-1]);//输出分隔后的数字（浮点型）
  		}
  		printf("\n");
  	};
  	Prt(figure);  //数字元素遍历,求数据的个数，数据的最大值，最小值，并输出
  	return figure;
  }
  //建立栈空间，初始化栈
  void Init_Stack(Stack **s)//Stack *Init_Stack(Stack *s,int x)
  {
  	*s = (Stack *)malloc(sizeof(Stack));
  	(*s)->next = NULL;
  }
  
  Stack *Push_Stack(Stack **top, char x)  //入栈
  {
  	Stack *s;
  	int i = 0;
  	s = (Stack *)malloc(sizeof(Stack));
  	s->data = x; s->next = *top; *top = s;
  	return *top;
  }
  
  Stack *Pop_Stack(Stack **top, char x)  //出栈
  {
  	Stack *p;
  	if (top == NULL) return NULL;
  	else
  	{
  		x = (*top)->data ;
  		p = *top;
  		*top = (*top)->next;
  		free(p);//释放内存
  		return *top;
  	}
  }
  
  char *Input(char item[MAXSIZE])  //输入字符数字元素
  {
  	char ch;
  	int i = 0;
  	printf("从键盘输入一行以“，”分隔的一组整数，以'#'结束输入：\n");
  	ch = getchar();
  	while (ch != '#')
  	{
  		item[i] = ch;
  		i++;
  		ch = getchar();
  	}
  	return item;
  }
  void *Output_Stack(Stack *num)  //输出栈元素
  {
  	int y = 0;
  	printf("输出栈内数字元素为（最后一个为结束符）：\n");
  	while (num != NULL)
  	{
  		printf("%c  ", num->data);
  		Pop_Stack(&num, y);
  	}
  	printf("\n");
  	return NULL;
  }
  void Prt(double figure[])  //数字元素遍历,求数据的个数，数据的最大值，最小值，并输出
  {
  	int i = 0;
  	if (figure[0] ==NULL)
  	{
  		printf("数组空！\n");
  	}
  	printf("数组存在的元素如下:\n");
  	double min = figure[0], max = figure[0];
  	while (figure[i]>=0)
  	{
  		printf("-->%3.3f ", figure[i]);
  		if (figure[i] <= min) min = figure[i];
  		if (figure[i] >= max) max = figure[i];
  		i++;
  	}
  	printf(" *******结束!\n");
  	printf("***数字个数为%3d个***\n", i);
  	printf("***最大数为：%3f***\n", max);
  	printf("***最小数为：%3f***\n", min);
  }
  

• 您还可以看一下 张勇老师的初级到CS开发高手通用权限管理系统全程实录课程中的 讲解和推进客户端智能升级流程小节, 巩固相关知识点
  

修改如下，改动处见注释，供参考：

#include <stdio.h>
#include <stdlib.h>
#define Max  10      //二叉树结点个数   修改

 //typedef enum { false, true } bool;   修改

typedef  int  ElementType ;           //修改

//其中BinTree结构定义如下：
typedef struct TNode* Position;    
typedef Position BinTree;          
struct TNode {
    ElementType Data;
    BinTree Left;        
    BinTree Right;                
}; 

struct QNode {
    BinTree* Data;  // char*  修改
    int f;
    int r;
    //int Max;
};
typedef struct QNode* Queue;

//函数接口定义：
void LevelorderTraversal(BinTree BT);

Queue CreatQueue() {
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Data = (BinTree*)malloc(Max * sizeof(BinTree));   // 修改
    //Q->Data = (char*)malloc(Max * sizeof(char));
    Q->f = Q->r = 0;
    return Q;
}
bool AddQ(Queue Q, Position X) {
    if ((Q->r + 1) % Max == Q->f)  //if ((Q->r + 1) % Q->Max == Q->f) 修改
        return false;
    else {
        Q->Data[Q->r] = X;
        Q->r = (Q->r + 1) % Max;  //Q->r = (Q->r + 1) % Q->Max; 修改
        return true;
    }
}
Position DeleteQ(Queue Q) {   //bool DeleteQ(Queue Q)     修改
    if (Q->r == Q->f) {
        //printf("invalid\n");
        return  NULL;      //false; 修改
    }
    else {
        Position X = Q->Data[Q->f]; // 修改  
        Q->f = (Q->f + 1) % Max;   //Q->f = (Q->f + 1) % Q->Max; 修改
        return   X;                //true 修改
    }
}
void LevelorderTraversal(BinTree BT) {
    Queue Q;
    BinTree T = NULL;
    if (!BT) return;
    T = BT;            //修改
    Q = CreatQueue();  //CreatQueue(Q);
    AddQ(Q, T);        //修改 
    while (Q->f < Q->r) { //while (!Q) 修改
        T = DeleteQ(Q);
        printf("%d", T->Data);
        if (T->Left) {
            AddQ(Q, T->Left);
        }
        if (T->Right) {
            AddQ(Q, T->Right);
        }
    }
}