C语言实现判断二叉树是否是完全二叉树

[小菜鸟成长记]

希望高人指点这个算法哪里不对
//判断二叉树是否是完全二叉树
#include<stdio.h>
#include<windows.h>
typedef struct Bitnode
{
public:
char data;
Bitnode *lchild,*rchild;
};
int i = 1;
Bitnode *head;
Bitnode* create(Bitnode *T)
{
char ch;
scanf("%c",&ch);
if(ch=='x')
T=NULL;
else
{
T=new Bitnode;
if(i == 1)
head = T;
i++;
if(!T)
{

printf("error!");
exit(1);
}
T->data =ch;
T->lchild =new Bitnode;
T->lchild=create(T->lchild );
T->rchild =new Bitnode;
T->rchild=create(T->rchild );
}
return T;
}
typedef struct
{
Bitnode data[10];
int front;
int rear;
}Queue;
void inital(Queue *q)
{
q->front =0;
q->rear =0;
}
void push(Queue *q,Bitnode t)
{
q->data [q->rear]=t;
q->rear++;
}
int isempty(Queue *q)
{
if(q->front ==q->rear )
return 1;
else
return 0;
}
Bitnode pop(Queue *q)
{
return q->data [q->front];
q->front++;
}
int Iserchashu(Bitnode *t,Queue *q)
{
Bitnode *p;
int flag=0;
push(q,*t);
while(!isempty(q))
{
*p=pop(q);
if(!p)
flag=1;
else
if(flag==1)
return 0;
push(q,*p->lchild );
push(q,*p->rchild );
}
}
void main()
{
Bitnode *t;
create(t);
Queue *q;
inital(q);
printf("%d",Iserchashu(head,q));
}

[W170532934]

你的二叉树都没有建立正确哦。
Bitnode* create()
{
char ch;
Bitnode* p = NULL;
scanf("%c",&ch);
if(ch=='x')
{
return NULL;
}
else
{
p = (Bitnode*)malloc(sizeof(Bitnode));
p->data = ch;
p->lchild = create();
p->rchild = create();
return p;
}
}

[至善者善之敌]

/*先要对二叉树进行层次遍历,在遍历过程中对每一个结点进行检查:
(1)如果当前结点没有右子树,则剩下的全部结点必须既没有左子树,又没有右子树;
(2)如果当前结点有右子树,则它必须也有左子树.

如果同时满足(1)(2),则是完全二叉树;否则不是.

对二叉树进行层次遍历需要使用队列结构.
*/

#include <stdio.h>
#include <malloc.h>

#define TRUE 1
#define FALSE 0
typedef int BOOL;

typedef char DATATYPE;
typedef struct _node
{
DATATYPE Data;
struct _node *pLeft;
struct _node *pRight;
} NODE;

/*队列*/
typedef struct
{
BOOL bIsEmpty;
int nFront;
int nRear;
int nSize;
NODE **pData;
} QUEUE;

/*队列初始化。nSize = 数组大小*/
void InitQueue(QUEUE *pQue, int nSize)
{
pQue-> pData = (NODE **)malloc(sizeof(NODE *) * nSize);
pQue-> nSize = nSize;
pQue-> nFront = pQue-> nRear = 0;
pQue-> bIsEmpty = TRUE;
}

/*入队列*/
BOOL InQueue(QUEUE *pQue, NODE *Data)
{
if (pQue-> bIsEmpty || pQue-> nRear != pQue-> nFront) /*判断队列是否满*/
{
pQue-> bIsEmpty = FALSE;
pQue-> pData[pQue-> nRear] = Data;
pQue-> nRear++;
if (pQue-> nRear == pQue-> nSize)
pQue-> nRear = 0;
return TRUE;
}
else
return FALSE;
}

/*出队列。pDataBfr为容纳数据的变量的指针*/
BOOL OutQueue(QUEUE *pQue, NODE **pDataBfr)
{
if (pQue-> bIsEmpty)
return FALSE;
else
{
*pDataBfr = pQue-> pData[pQue-> nFront];
pQue-> nFront++;
if (pQue-> nFront == pQue-> nSize)
pQue-> nFront = 0;
if (pQue-> nFront == pQue-> nRear)
pQue-> bIsEmpty = TRUE;
return TRUE;
}
}

/*二叉树的层次遍历并判断是否为完全二叉树*/
BOOL LevelTraverse(NODE *pRoot)
{
BOOL bResult = TRUE;
BOOL bComfine = FALSE;
NODE *pCurNode;
QUEUE Que;

if (pRoot == NULL)
return TRUE;

InitQueue(&Que,1024); /*这里不考虑队列溢出，在应用中应根据实际情况使用合适
的队列*/
InQueue(&Que,pRoot);

while (OutQueue(&Que,&pCurNode))
{
if (!pCurNode-> pLeft && pCurNode-> pRight)
{
bResult = FALSE;
break;
}
if (bComfine && (pCurNode-> pLeft || pCurNode-> pRight))
{
bResult = FALSE;
break;
}
if (pCurNode-> pLeft)
InQueue(&Que,pCurNode-> pLeft);
if (pCurNode-> pRight)
InQueue(&Que,pCurNode-> pRight);
else
bComfine = TRUE;
}
return bResult;
}

/*简单的测试环境*/

/* 从键盘缓冲区中读取一个不为空格且不为回车的字符 */
char GetNextChar(void)
{
char ch;
do
{
ch = getchar();
} while (ch == ' ' || ch == '\n ');
return ch;
}

/*利用前序遍历序列建立二叉树。扩充结点用‘*’代表。前序序列从键盘输入*/
void CreateTree(NODE *Root)
{
Root-> pLeft = Root-> pRight = NULL;
if (Root-> Data != '* ') /* 如果不为扩充结点, 要建立左结点和右结点 */
{
Root-> pLeft = (NODE *)malloc(sizeof(NODE));
Root-> pLeft-> Data = GetNextChar();
CreateTree(Root-> pLeft);
Root-> pRight = (NODE *)malloc(sizeof(NODE));
Root-> pRight-> Data = GetNextChar();
CreateTree(Root-> pRight);
}
}

/*除去 '* '结点*/
void TrimTree(NODE *pRoot)
{
if (pRoot-> pLeft)
if (pRoot-> pLeft-> Data == '* ')
{
free(pRoot-> pLeft);
pRoot-> pLeft = NULL;
}
else
TrimTree(pRoot-> pLeft);
if (pRoot-> pRight)
if (pRoot-> pRight-> Data == '* ')
{
free(pRoot-> pRight);
pRoot-> pRight = NULL;
}
else
TrimTree(pRoot-> pRight);
}

void main()
{
NODE Root;

Root.Data = GetNextChar();
CreateTree(&Root);
TrimTree(&Root);

printf( "%d\n ",LevelTraverse(&Root));
}