数据结构C语言——用二叉链表示二叉树

头文件，定义栈和结构体的功能：

/* 二叉树的链接表示*/
#include <stdio.h>
#include <stdlib.h>

typedef char DataType;

struct BinTreeNode;	 
typedef  struct BinTreeNode	 *PBinTreeNode;/* 二叉树中结点 */
typedef struct BinTreeNode { 
	DataType  info;	                        /* 数据域 */
	PBinTreeNode llink;                     /* 指向左子女 */
	PBinTreeNode rlink;                     /* 指向右子女 */
}BTnode;
typedef struct BinTreeNode *PBinTree;

/*队列的结构体定义*/
#define  queueSize 20
struct Sequeue{
	int r,f;
	PBinTree q[queueSize];
};
typedef struct Sequeue *Pqueue;
//声明队列函数
Pqueue creatEmptyQueue(void);
int isEmptySqueue(Pqueue qu);
void insertQueue(Pqueue qu,PBinTree x);
void deleteQueue(Pqueue qu);
PBinTree topQueueElement(Pqueue qu);

//创建空队列
Pqueue creatEmptyQueue(void){
	Pqueue qu=(Pqueue)malloc(sizeof(struct Sequeue));
	if (qu==NULL)
	{
		printf("out of space");
	} 
	else
	{
		qu->f=qu->r=0;
		return qu;
	}
}


//判断队列是否为空
int isEmptySqueue(Pqueue qu){
	return qu->f==qu->r;//队尾=队头，则队列为空
}

//在队列中插入某一个元素
void insertQueue(Pqueue qu,PBinTree x){
	//首先判断队列是否已满
	if ((qu->r+1)%queueSize==qu->f)
	{
		printf("full queue");
	} 
	else
	{    //尾进头出
		qu->q[qu->r]=x;//x插入当前队尾所指的位置
		//qu->r=qu->r+1;
		qu->r=(qu->r+1)%queueSize;//循环队列的长度加一
	}
}

//删除队列头部元素
void deleteQueue(Pqueue qu){
	//首先判断队列是否已空
	if (isEmptySqueue(qu))
	{
		printf("queue is empty");
	} 
	else
	{
		qu->f=qu->f+1;//使队头的下一个结点成为队头，那么当前的队头就出栈了
	}
}

//对于非空队列，求队头元素
PBinTree topQueueElement(Pqueue qu){
	return qu->q[qu->f];//返回队头指向的当前元素
}

//*******************************************************************/

//判断队列是否已满
int isFullQueue(Pqueue qu){
	return (qu->r+1)%queueSize==qu->f;//队尾加一等于队头，则满
}


/* 结点的指针类型 */

#define  stackSize 100//定义常量不需加分号
 struct stack{
	int top;//指向栈顶元素的指针
	PBinTree s[stackSize];//栈的空间大小
}Seqstack;
typedef struct stack *Pstack;

/*声明函数*/
Pstack createEmptyStack_ps();
int isEmptyStack_ps(Pstack s);
void pushStack(Pstack ps,PBinTree x);
void pop_stack(Pstack s);
PBinTree topStack(Pstack s);

//创建一个空栈并初始化

Pstack createEmptyStack_ps(){
	Pstack s=(Pstack)malloc(sizeof(struct stack));
	if (s==NULL)
	{
		printf("out of space!");
	}else{
		s->top=-1;//栈顶元素赋值为-1
	}
	return s;
}

//判断栈是否为空
int isEmptyStack_ps(Pstack s){
	return s->top==-1;//空栈返回1，否则返回0
}

//进栈
void pushStack(Pstack ps,PBinTree x){
	if (ps->top>=stackSize-1)
	{
		printf("over flow");
	} 
		ps->top++;//栈顶元素指针加1
		ps->s[ps->top]=x;
}



//取栈顶元素
PBinTree topStack(Pstack s){
	return (s->s[s->top]);
}

//出栈
void pop_stack(Pstack s){
	if (isEmptyStack_ps(s))
	{
		printf("under flow");
	}
	else{
		s->top--;//栈顶指针减1
	}
}

源文件：

#include "PStack.h"

/* 递归创建从根开始的二叉树 ,中序遍历创建二叉树*/
PBinTree createRest_BTree() { 
	PBinTree  pbnode;
	char ch;
	scanf("%c", &ch);
	if(ch == '@') {
		pbnode = NULL;
	}
	else { 
		pbnode = (PBinTree)malloc(sizeof(struct BinTreeNode));
		if( pbnode == NULL )         {
			printf("Out of space!\n");
			return pbnode;
		}
		pbnode->info = ch;
		pbnode->llink = createRest_BTree();	/* 构造左子树 */
		pbnode->rlink = createRest_BTree();	/* 构造右子树 */
	}
	return pbnode;
}


//用栈实现二叉树的先序遍历
/*void FristReadBinTree(PBinTree t){
	PBinTree p;
	Pstack s;
	if (t==NULL)
	{
		return;
	}
	 s=createEmptyStack_ps();
	pushStack(s,t);
	while (!isEmptyStack_ps(s))
	{
		p=topStack(s);
		pop_stack(s);
		if (p!=NULL)
		{
			printf("%c ",p->info);
			pushStack(s,p->rlink);
			pushStack(s,p->llink);
		}
	}
}
//中序遍历二叉树
void minReadBinTree(PBinTree t){
	PBinTree p=t;
	Pstack s=createEmptyStack_ps();
	if (p==NULL)
	{
		return;
	}
	do
	{
		while (p!=NULL)
		{
			
			pushStack(s,p);
			p=p->llink;
		}
			p=topStack(s);
			pop_stack(s);
			printf("%c ",p->info);
			p=p->rlink;
	}while (p!=NULL||!isEmptyStack_ps(s));

}*/

//层次遍历
void chengciReadBinTree(PBinTree t){
	PBinTree c,cc;
	Pqueue q=creatEmptyQueue();
	if (t==NULL)
	{
		return;
	}
	c=t;insertQueue(q,c);
	while (!isEmptySqueue(q))
	{
		c=topQueueElement(q);
		deleteQueue(q);
		printf("%c ",c->info);

		cc=c->llink;if (cc!=NULL)
		{
			insertQueue(q,cc);
		}

		cc=c->rlink;if (cc!=NULL)
		{
			insertQueue(q,cc);
		}
	}
}

//中序遍历统计叶子结点的个数
int countLea(PBinTree p){
	static int count;
	if (p!=NULL)
	{
	countLea(p->llink);
	if ((!p->llink)&&(!p->rlink))
	{
		count++;
	}
	countLea(p->rlink);
	}
	return count;
	printf("fuck");
}

void main(){
	int count;
	printf("输入字符创建二叉树：\n");
	PBinTree p=createRest_BTree();
	printf("层次遍历二叉树：\n");
	//FristReadBinTree(p);//先序遍历
	//minReadBinTree(p);//中序遍历
	chengciReadBinTree(p);//层次遍历
	printf("叶子结点个数：\n");
	count=countLea(p);
	printf("%d\n",count);
}