二叉树的层次，中序，先序，中序，后序遍历的递归和非递归算法以及查询二叉树的祖先节点的算法，查询小写字母的个数

#include <stdio.h>
#include <malloc.h>
#define MaxSize 100
typedef char ElemType;
typedef struct node 
{	
	ElemType data;			//数据元素
	struct node *lchild;	//指向左孩子节点
	struct node *rchild;	//指向右孩子节点
} BTNode;
void PreOrder(BTNode *b)
{
	if(b!=NULL)
	{
		printf("%c",b->data);
		PreOrder(b->lchild);
		PreOrder(b->rchild);
	}
}
void PreOrder1(BTNode *b)
{
	BTNode *St[MaxSize],*p;
	int top=-1;
	if(b!=NULL)
	{
		top++;
		St[top]=b;
		while(top>-1)
		{	p=St[top];
			top--;
			printf("%c",p->data);
			if(p->rchild!=NULL)
			{
				top++;
				St[top]=p->rchild;
			}
			if(p->lchild!=NULL)
			{
				top++;
				St[top]=p->lchild;
			}
		}
		printf("\n");
	}
}
void InOrder(BTNode *b)
{
	if(b!=NULL)
	{
		InOrder(b->lchild);
		printf("%c",b->data);
		InOrder(b->rchild);
	}
}
void InOrder1(BTNode *b)
{
	BTNode *St[MaxSize],*p;
	int top=-1;
	if(b!=NULL)
	{
		p=b;
		while(top>-1||p!=NULL)
		{
			while(p!=NULL)
			{
				top++;
				St[top]=p;
				p=p->lchild;
			}
			if(top>-1)
			{
				p=St[top];
				top--;
				printf("%c",p->data);
				p=p->rchild;
			}
		}
		printf("\n");
	}
}
void PostOrder(BTNode *b)
{
	if(b!=NULL)
	{
		PostOrder(b->lchild);
		PostOrder(b->rchild);
		printf("%c",b->data);
	}
}
void PostOrder1(BTNode *b)
{
	BTNode *St[MaxSize];
	BTNode *p;
	int top=-1;
	bool flag;
	if(b!=NULL)
	{
		do
		{
			while(b!=NULL)
			{
				top++;
				St[top]=b;
				b=b->lchild;
			}
			p=NULL;
			flag=true;
			while(top!=-1&&flag)
			{
				b=St[top];
				if(b->rchild==p)
				{
					printf("%c",b->data);
					top--;
					p=b;
				}
				else
				{
					b=b->rchild;
					flag=false;
				}
			}
		}while(top!=-1);
		printf("\n");
	}
}
void TravLevel(BTNode *b)
{
	BTNode *Qu[MaxSize];
	int front,rear;
	front=rear=0;
	if(b!=NULL) printf("%c",b->data);
	rear++;
	Qu[rear]=b;
	while(rear!=front)
	{
		front=(front+1)%MaxSize;
		b=Qu[front];
		if(b->lchild!=NULL)
		{
			printf("%c",b->lchild->data);
			rear=(rear+1)%MaxSize;
			Qu[rear]=b->lchild;
		}
		if(b->rchild!=NULL)
		{
			printf("%c",b->rchild->data);
			rear=(rear+1)%MaxSize;
			Qu[rear]=b->rchild;
		}
	}
	printf("\n");
}
//求二叉树中某一个节点的所有祖先节点
bool ancestor(BTNode *b,ElemType x)
{
	if(b==NULL)
		return false;
	else if(b->lchild!=NULL&&b->lchild->data==x||b->rchild!=NULL&&b->rchild->data==x)
	{
		printf("%c ",b->data);
		return true;
	}
	else if(ancestor(b->lchild,x)||ancestor(b->rchild,x))
	{
		printf("%c ",b->data);
		return true;
	}
	else return false;
}

int fun(BTNode *b)
{	BTNode *St[MaxSize],*p;
	int top=-1;
	int count=0;
	if(b!=NULL)
	{
		top++;
		St[top]=b;
		while(top>-1)
		{	p=St[top];
			top--;
			if(p->data>=97&&p->data<=122){
				printf("%c",p->data);
				count++;
			}	
			if(p->rchild!=NULL)
			{
				top++;
				St[top]=p->rchild;
			}
			if(p->lchild!=NULL)
			{
				top++;
				St[top]=p->lchild;
			}
		}
		return (count);
	}
}

//****************************************************************************************************
//二叉树的基本运算算
void CreateBTree(BTNode * &b,char *str)	//创建二叉树
{
	BTNode *St[MaxSize],*p=NULL;
	int top=-1,k,j=0;  
	char ch;
	b=NULL;				//建立的二叉树初始时为空
	ch=str[j];
	while (ch!='\0')  	//str未扫描完时循环
	{
   	   	switch(ch) 
		{
		case '(':top++;St[top]=p;k=1; break;		//为左孩子节点
		case ')':top--;break;
		case ',':k=2; break;                      		//为孩子节点右节点
		default:p=(BTNode *)malloc(sizeof(BTNode));
				p->data=ch;p->lchild=p->rchild=NULL;
				if (b==NULL)                    	 	//*p为二叉树的根节点
					b=p;
				else  								//已建立二叉树根节点
				{	
					switch(k) 
					{
					case 1:St[top]->lchild=p;break;
					case 2:St[top]->rchild=p;break;
					}
				}
		}
		j++;
		ch=str[j];
	}
}
void DestroyBTree(BTNode *&b)
{	if (b!=NULL)
	{	DestroyBTree(b->lchild);
		DestroyBTree(b->rchild);
		free(b);
	}
}
BTNode *FindNode(BTNode *b,ElemType x) 
{
	BTNode *p;
	if (b==NULL)
		return NULL;
	else if (b->data==x)
		return b;
	else  
	{
		p=FindNode(b->lchild,x);
		if (p!=NULL) 
			return p;
		else 
			return FindNode(b->rchild,x);
	}
}
BTNode *LchildNode(BTNode *p)
{
    return p->lchild;
}
BTNode *RchildNode(BTNode *p)
{
    return p->rchild;
}
int BTHeight(BTNode *b) 
{
   	int lchildh,rchildh;
   	if (b==NULL) return(0); 				//空树的高度为0
   	else  
	{
		lchildh=BTHeight(b->lchild);	//求左子树的高度为lchildh
		rchildh=BTHeight(b->rchild);	//求右子树的高度为rchildh
		return (lchildh>rchildh)? (lchildh+1):(rchildh+1);
   	}
}
void DispBTree(BTNode *b) 
{
	if (b!=NULL)
	{	printf("%c",b->data);
		if (b->lchild!=NULL || b->rchild!=NULL)
		{	printf("(");						//有孩子节点时才输出(
			DispBTree(b->lchild);				//递归处理左子树
			if (b->rchild!=NULL) printf(",");	//有右孩子节点时才输出,
			DispBTree(b->rchild);				//递归处理右子树
			printf(")");						//有孩子节点时才输出)
		}
	}
}

//***********************************************
int main()
{
	BTNode *b;
	CreateBTree(b,"A(b(D,E(h(J,K(L,M(N))))),c(F,G(,I)))");
	printf("二叉树b:"); DispBTree(b); printf("\n");
	printf("层次遍历序列");
	TravLevel(b);
	printf("先序遍历序列\n");
	printf("	递归算法:"); PreOrder(b); printf("\n");
	printf("	非递归算法"); PreOrder1(b);
	printf("中序遍历序列\n"); 
	printf("	递归算法:"); InOrder(b); printf("\n");
	printf("	非递归算法"); InOrder1(b); 
	printf("后序遍历序列\n"); 
	printf("	递归算法:"); PostOrder(b); printf("\n");
	printf("	非递归算法"); PostOrder1(b);
	printf("查询先祖节点，以点M为例"); ancestor(b,'M'); printf("\n"); 
	printf("小写字母节点个数%d\n",fun(b));
	DestroyBTree(b);
	return 1;
}