1.構造一棵二叉樹,樹的形態如下圖所示，打印出前序遍歷、中序遍歷、後序遍歷的遍歷序列。

2.選擇一種遍歷方式計算該樹中葉子結點的個數，並打印出葉子結點。

3.編寫一個查詢演算法，查詢資料“E”是否存在。

#include"stdlib.h"
#include"stdio.h"
typedef char DataType;
#include"BiTree.h"
#define MaxStackSize 100
/*typedef char ElemType;*/
typedef BiTreeNode* ElemType;
#include "SeqStack.h"
#include "LinQueue.h"

void main()
{
	BiTreeNode *root;
	Initiate(&root);
	if(root!=NULL)
		root=createbintree();
	printf("先序遍歷:");
	PreOrder(root,visit);  //先序遍歷
	printf("\n");
	printf("中序遍歷:");
	InOrder(root,visit);  //中序遍歷
	printf("\n");
	printf("後序遍歷:");
	PostOrder(root,visit);  //後序遍歷
	printf("\n");
	printf("二叉樹中結點個數為：%d\n",numofnode(root));
	printf("二叉樹中葉子結點個數為：%d\n",preleafnum(root));
	printf("\n/**************************************************************************************/\n\n");
    LayerOrder(root);
	printf("非遞迴先序遍歷:");
	PreOrderByStack(root);
	printf("非遞迴中序遍歷:");
	InOrderByStack(root);
	printf("佇列結構層序遍歷為:");
	LayerOrder2(root);
	printf("\n");
	Destroy(&root);
}
 

typedef struct Node
{
	DataType data;                /*資料域*/
	struct Node *leftChild;       /*左子樹指標*/
	struct Node *rightChild;      /*右子樹指標*/
}BiTreeNode;                      /*結點的結構體定義*/

void Initiate(BiTreeNode **root)  /*初始化建立二叉樹的頭結點*/
{
	*root=(BiTreeNode *)malloc(sizeof(BiTreeNode));
	(*root)->leftChild=NULL;
	(*root)->rightChild=NULL;
}

void Destroy(BiTreeNode **root)
{
	if((*root)!=NULL&&(*root)->leftChild!=NULL)
		Destroy(&(*root)->leftChild);
	if((*root)!=NULL&&(*root)->rightChild!=NULL)
		Destroy(&(*root)->rightChild);
	free(*root);
}

/*若當前結點curr非空，在curr的左子樹插入元素值為x的新結點*/
/*原curr所指結點的左子樹成為新插入結點的左子樹*/
/*若插入成功返回新插入結點的指標，否則返回空指標*/

BiTreeNode *InsertleftNode(BiTreeNode *curr,DataType x)
{
	BiTreeNode *s,*t;
	if(curr==NULL)
		return NULL;
	t=curr->leftChild;
	s=(BiTreeNode *)malloc(sizeof(BiTreeNode));
	s->data=x;
	s->leftChild=t;
	s->rightChild=NULL;
	curr->leftChild=s;
	return curr->leftChild;
}

BiTreeNode *InsertRightNode(BiTreeNode *curr,DataType x)
{                                          
	BiTreeNode *s,*t;
	if(curr==NULL)
		return NULL;
	t=curr->rightChild;       /*儲存原curr所指結點的右子樹指標*/
	s=(BiTreeNode *)malloc(sizeof(BiTreeNode));
	s->data=x;
	s->rightChild=t;          /*新插入結點的右子樹為原curr的右子樹*/
	s->leftChild=NULL;
	curr->rightChild=s;       /*新結點成為curr的右子樹*/
	return curr->rightChild;  /*返回新插入結點的指標*/
}

BiTreeNode *DeleteLeftTree(BiTreeNode *curr)  /*若curr非空，刪除curr所指結點的左子樹*/
{
	if(curr==NULL||curr->leftChild==NULL)
		return NULL;
	Destroy(&curr->leftChild);
	curr->leftChild=NULL;
	return curr;                              /*若刪除成功返回刪除結點的雙親結點指標，否則返回空指標*/
}

BiTreeNode *DeleteRightTree(BiTreeNode *curr)
{
	if(curr==NULL||curr->rightChild==NULL)
		return NULL;
	Destroy(&curr->rightChild);
	curr->rightChild=NULL;
	return curr;
}

void PreOrder(BiTreeNode *t,void visit(DataType item))
{
	if(t!=NULL)
	{
		visit(t->data);
		PreOrder(t->leftChild,visit);
		PreOrder(t->rightChild,visit);
	}
}

void InOrder(BiTreeNode *t,void visit(DataType item))
{
	if(t!=NULL)
	{
		InOrder(t->leftChild,visit);
		visit(t->data);
		InOrder(t->rightChild,visit);
	}
}

void PostOrder(BiTreeNode *t,void visit(DataType item))
{
	if(t!=NULL)
	{
		PostOrder(t->leftChild,visit);
		PostOrder(t->rightChild,visit);
		visit(t->data);
	}
}

void visit(DataType item)
{
	printf("%c",item);
}

void visit2(BiTreeNode *t)
{
	printf("%c",t->data);
}

BiTreeNode *createbintree(void)
{
	BiTreeNode *pbnode;
	char ch;
	scanf("%c",&ch);
	if(ch=='#')
		pbnode=NULL;
	else
	{
		pbnode=(BiTreeNode *)malloc(sizeof(BiTreeNode));
		if(pbnode==NULL)
			return pbnode;
		//InsertleftNode(pbnode,ch);
		pbnode->data=ch;
		pbnode->leftChild=createbintree();
		pbnode->rightChild=createbintree();
	}
	return pbnode;
}

int numofnode(BiTreeNode *t)
{
	if(t==NULL)
		return 0;
	else
		return(numofnode(t->leftChild)+numofnode(t->rightChild)+1);
}

int preleafnum(BiTreeNode *t)
{
	if(t==NULL)
		return 0;
	else
	{
		if((t->leftChild==NULL)&&(t->rightChild==NULL))
		{
			return 1;
		}
		return preleafnum(t->leftChild)+preleafnum(t->rightChild);
	}
}

/*int locate(BiTreeNode *t,DataType x)
{
	BiTreeNode *p;
	if(t==NULL)
		return 0;
	if(t->data==x)
		return 1;
	else
	{
		p=locate(t->leftChild,x);
		if(p)
			return 1;
		else
			return locate(t->rightChild,x);
	}
}*/

void LayerOrder(BiTreeNode *T)

{	int front=0,rear=1;
	BiTreeNode *a[100];
    a[0]=T;
	printf("非佇列結構層序遍歷為:");
    while(front<rear)
    {
        if(a[front])
        {
            printf("%c",a[front]->data);
			if(a[front]->leftChild!=NULL)
            {	a[rear++]=a[front]->leftChild;
			}
			if(a[front]->rightChild!=NULL)
            {	a[rear++]=a[front]->rightChild;
			}
            front++;
        }
        else
        {
            front++;
        }
    }
	printf("\n");
}

BiTreeNode *leftchild(BiTreeNode *p)
{
	if(p==NULL)
		return NULL;
	return p->leftChild;
}

BiTreeNode *rightchild(BiTreeNode *p)
{
	if(p==NULL)
		return NULL;
	return p->rightChild;
}
 

typedef struct qnode
{
	ElemType data;
	struct qnode *next;
}LQNode;

typedef struct
{
	LQNode *front;  /*隊頭指標*/
	LQNode *rear;   /*隊尾指標*/
}LQueue;

void QueueInitiate(LQueue *Q)  /*初始化鏈式佇列Q*/
{
	Q->rear=NULL;  /*定義初始隊尾指標下標值*/
	Q->front=NULL;  /*定義初始隊頭指標下標值*/
}

int QueueNotEmpty(LQueue Q)  /*判鏈式佇列Q非空否，非空則返回1，否則返回0*/
{
	if(Q.front==NULL) return 0;
	else return 1;
}

int QueueAppend(LQueue *Q,ElemType x)  /*把資料元素值x插入鏈式佇列Q的隊尾，入佇列成功則返回1，否則返回0 */
{
	LQNode *p;
	if((p=(LQNode *)malloc(sizeof(LQNode)))==NULL)
	{
		printf("記憶體空間不足！");
		return 0;
	}
	p->data=x;
	p->next=NULL;
	if(Q->rear!=NULL)
		Q->rear->next=p;
	Q->rear=p;
	if(Q->front==NULL)
		Q->front=p;
	return 1;
}

int QueueDelete(LQueue *Q,ElemType *d)  /*刪除鏈式佇列Q的隊頭資料元素值到d ，出佇列成功則返回1，否則返回0*/
{
	LQNode *p;
	if(Q->front==NULL)
	{
		printf("佇列已空無資料元素出佇列！\n");
		return 0;
	}
	else
	{
		*d=Q->front->data;
		p=Q->front;
		Q->front=Q->front->next;
		if(Q->front==NULL)
			Q->rear=NULL;
		free(p);
		return 1;
	}
}

int QueueGet(LQueue Q,ElemType *d)  /*取鏈式佇列Q的當前隊頭資料元素值到d ，成功則返回1，否則返回0*/
{
	if(Q.front==NULL)
	{
		printf("佇列已空無資料元素出佇列！\n");
		return 0;
	}
	else
	{
		*d=Q.front->data;
		return 1;
	}
}

void Destroy1(LQueue Q)
{
	LQNode *p,*p1;
	p=Q.front;
	while(p!=NULL)
	{
		p1=p;
		p=p->next;
		free(p1);
	}
}

void LayerOrder2(BiTreeNode *T)
{
	LQueue myQueue;
	BiTreeNode *Q;
	/*Initiate(&Q);*/
	QueueInitiate(&myQueue);
	QueueAppend(&myQueue,T);
	while(QueueNotEmpty(myQueue)==1)
	{
		QueueDelete(&myQueue,&Q);
		visit2(Q);
		if(Q->leftChild!=NULL)
			QueueAppend(&myQueue,Q->leftChild);
		if(Q->rightChild!=NULL)
			QueueAppend(&myQueue,Q->rightChild);
	}
}
 

typedef struct
{
	ElemType stack[MaxStackSize];
	int top;
}SeqStack;

void StackInitiate(SeqStack *S)  /*初始化順序堆疊S*/
{
	S->top=0;                    /*定義初始棧頂下標值*/
}

int StackNotEmpty(SeqStack S)    /*判順序堆疊S非空否，非空則返回1，否則返回0*/
{
	if(S.top<=0)
		return 0;
	else return 1;
}

int StackPush(SeqStack *S,ElemType x)  /*把資料元素值x壓入順序堆疊S，入棧成功則返回1，否則返回0 */
{
	if(S->top>=MaxStackSize)
	{
		printf("堆疊已滿無法插入!\n");
		return 0;
	}
	else
	{
		S->stack[S->top]=x;
		S->top++;
		return 1;
	}
}

int StackPop(SeqStack *S,ElemType *d)    /*彈出順序堆疊S的棧頂資料元素值到引數d ，出棧成功則返回1，否則返回0*/
{
	if(S->top<=0)
	{
		printf("堆疊已空無法插入!\n");
		return 0;
	}
	else
	{
		S->top--;
		*d=S->stack[S->top];
		return 1;
	}
}

int StackTop(SeqStack S,ElemType *d)   /*取順序堆疊S的當前棧頂資料元素值到引數d ，成功則返回1，否則返回0*/
{
	if(S.top<=0)
	{
		printf("堆疊已空!\n");
		return 0;
	}
	else
	{
		*d=S.stack[S.top-1];
		return 1;
	}
}

void PreOrderByStack(BiTreeNode *root)
{
	SeqStack s;
	BiTreeNode *p=root;
	StackInitiate(&s);
	while(StackNotEmpty(s)||p)  //StackNotEmpty(SeqStack S)
	{
		if(p)
		{
			visit2(p);
			StackPush(&s,p);  //StackPush(SeqStack *S,DataType x)
			p=leftchild(p);
		}
		else
		{
			StackPop(&s,&p);  //StackPop(SeqStack *S,DataType *d)
			p=rightchild(p);
		}
	}
	printf("\n");
}

void InOrderByStack(BiTreeNode *root)
{
    SeqStack s;
	BiTreeNode *p=root;
	StackInitiate(&s);
	while(StackNotEmpty(s)||p)  //StackNotEmpty(SeqStack S)
	{
		if(p)
		{
			//visit(p);
			StackPush(&s,p);  //StackPush(SeqStack *S,DataType x)
			p=leftchild(p);
		}
		else
		{
			StackPop(&s,&p);  //StackPop(SeqStack *S,DataType *d)
			visit2(p);
			p=rightchild(p);
		}
	}
	printf("\n");
}