数据结构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);
}