实验五 二叉树的建立及遍历应用

一、【实验目的】
1、掌握二叉树的建立方法

2、掌握二叉树遍历的基本方法（先序、中序、后序）

3、掌握递归二叉树遍历算法的应用

二、【实验内容】

1.构造一棵二叉树,打印出先序遍历、中序遍历、后序遍历的遍历序列。

2.选择一种遍历方式计算该树中叶子结点的个数，并打印出叶子结点。

提示:

先根据给定的树，写出此树的扩展先序遍历序列，然后根据此遍历序列建立二叉树。

3.选作题:编写一个层序遍历算法，利用队列结构按层次（同一层自左至右）输出二叉树中所有的结点。

 

三、【实验源代码】

头文件
typedef struct LBinaryTreeNode
{
	ElemType data;
	struct  LBinaryTreeNode *lchild;
	struct  LBinaryTreeNode *rchild;
}LPBTreeNode;
void Initiate(LPBTreeNode *p)  /*初始化创建二叉树的头结点*/
{
	p=(LPBTreeNode *)malloc(sizeof(LPBTreeNode));
	p->lchild =NULL;
	p->rchild=NULL;
	
}
LPBTreeNode *createbintree()
{
	LPBTreeNode *pbnode;
	char ch;
	scanf("%c",&ch);
	if(ch=='#')pbnode=NULL;
	else
	{
		pbnode=(LPBTreeNode *)malloc(sizeof(LPBTreeNode));
		if(pbnode==NULL)
		{
			printf("out of space!\n");
			return pbnode;
		}
		pbnode->data =ch;
		pbnode->lchild =createbintree();
		pbnode->rchild =createbintree();
	}
	return pbnode;
}

void preorder(LPBTreeNode *t)
{
	if(t==NULL)return;
	printf("%c",t->data);
	preorder(t->lchild );
	preorder(t->rchild );
}
void inorder(LPBTreeNode *t)
{
	if(t==NULL)return ;
	inorder(t->lchild );
	printf("%c",t->data);
	inorder(t->rchild );
}
void postorder(LPBTreeNode *t)
{
	if(t==NULL)return ;
	postorder(t->lchild );
	postorder(t->rchild );
	printf("%c",t->data);
}
void leaf(LPBTreeNode *p)
{
	if(p!=NULL)
	{
		if((p->lchild==NULL)&&(p->rchild ==NULL))
		printf("%c",p->data);
		leaf(p->lchild );
		leaf(p->rchild );
	}
}

主函数
#include<stdio.h>
#include<stdlib.h>
typedef  char ElemType;
#include"LBinaryTreeNode.h"

int main()
{
	LPBTreeNode *p; 
	Initiate(p);
	if(p!=NULL)
	{
	   p=createbintree();
    }
	printf("先序遍历:\n");
	preorder(p);
	printf("\n中序遍历:\n");
	inorder(p);
	printf("\n后序遍历:\n");
	postorder(p);
    printf("\n打印叶子节点:\n");
	leaf(p);
    return 0;
}
选做题
头文件
typedef struct Node
{
    char data;
    struct Node *LChild, *RChild;
}BiNode, *BiTree;

typedef struct
{
    BiTree data[QueueMax];
    int head;
    int rear;
    int len;
}Queue;
BiTree CreateTree()
{  //建立二叉树
    char c;
    scanf("%c",&c);
    BiTree T;
    if (c == '#') {
        return NULL;
    }
    T = (BiTree) malloc (sizeof(BiNode));
    T->data = c;
    T->LChild = CreateTree();
    T->RChild = CreateTree();
    return T;
}

Queue InitQueue()
{  //初始化队列
    Queue seq;
    int i; 
    for( i = 0; i < QueueMax; i++) 
	{
        seq.data[i] = NULL;
    }
    seq.head = 0;
    seq.rear = -1;
    seq.len = 0;
    return seq;
}

int IsEmptyQueue(Queue seq)
{  //队列判空
    if (seq.len == 0) {
        return 1;
    }
    return 0;
}

int IsFullQueue(Queue seq)
{  //队列判满
    if (seq.len == QueueMax) {
        return 1;
    }
    return 0;
}

void PushQueue(Queue *seq, BiTree T)
{  //入队
    if (IsFullQueue(*seq)) {
        printf("ErrorFull");
        return;
    }
    seq->rear = (seq->rear + 1) % QueueMax;
    seq->len++;
    seq->data[seq->rear] = T;
}

void PopQueue(Queue *seq, BiTree *T)
{  //出队
    if (IsEmptyQueue(*seq)) {
        printf("ErrorEmpty");
        return;
    }
    seq->head = (seq->head + 1) % QueueMax;
    *T = seq->data[seq->head];
    seq->len--;
}

void LayerOrder(BiTree T)
{  //层序遍历
    Queue seq;
    seq = InitQueue();
    BiTree tmp;
    tmp = T;
    PushQueue(&seq, tmp);
    while(!IsEmptyQueue(seq)) {
        printf("%c", tmp->data);
        if (tmp->LChild != NULL) {
            PushQueue(&seq, tmp->LChild);
        }
        if (tmp->RChild != NULL) {
            PushQueue(&seq, tmp->RChild);
        }
        PopQueue(&seq, &tmp);
    }
}

主函数
#include <stdio.h>
#include <stdlib.h>
#define QueueMax 100
#include"Tree.h"
int main()
{
    BiTree T;
    T = CreateTree();
    printf("层序遍历：\n");
    LayerOrder(T);
    return 0;
}