数据结构二叉树实验考试

1. 实验题目：二叉树操作设计和实现
2. 实验目的：掌握二叉树的定义、性质及存储方式，各种遍历算法。
3. 实验要求：采用二叉链表作为存储结构，完成二叉树的建立，先序、中序和后序以及按层次遍历的操作，求所有叶子结点及结点总数的操作。
4. 实验主要步骤：

• 编写二叉树的存储结构
• 编写二叉树的初始化算法（创建二叉树）
• 编写二叉树的先序、中序、后序、层次遍历算法
• 编写求二叉树的深度、叶子结点个数、结点总数算法
• 调试程序，编写main函数，设计一颗二叉树，输入完全二叉树的先序序列，用#代表虚节点（空指针），如abd###ce##f##，建立二叉树，求出先序、中序和后序及按层次遍历序列，求所有叶子结点数及结点总数。
• 要求有实验代码、实验结果及心得体会

实验代码：

#include<stdio.h>
#include<malloc.h>
#include<string.h>
#include<stdlib.h>
#include<iostream>
#define MAXSIZE 1000
using namespace std;



typedef struct BiTNode
{
    char data; // 结点数据域 
    struct BiTNode *lchild,*rchild; // 左右孩子指针 
}BiTNode,*BiTree;

void CreateBiTree(BiTree &T) // 先序遍历建立二叉链表 
{
    char ch;
    cin>>ch;
   //scanf("%c",&ch);
    if(ch=='#')
        T=NULL;
    else
    {
        T=(BiTNode *)malloc(sizeof(BiTNode));
        T->data=ch;
        CreateBiTree(T->lchild);
        CreateBiTree(T->rchild);
    }
}

void travel1(BiTree T) // 先序遍历 
{
    if(T)
    {
        printf("%c",T->data);
        travel1(T->lchild);
        travel1(T->rchild);
    }
}

void travel2(BiTree T) // 中序遍历 
{
    if(T)
    {
        travel2(T->lchild);    
        printf("%c",T->data);
        travel2(T->rchild);
    }
}

void travel3(BiTree T) // 后序遍历 
{
    if(T)
    {
        travel3(T->lchild);
        travel3(T->rchild);
        printf("%c",T->data);
    }
}

void LevelOrder(BiTNode *T)// 层次遍历
{
	BiTNode *p;
	BiTNode *qu[MAXSIZE];
	int front,rear;
	front=rear=-1;
	rear++;
	qu[rear]=T;
	while(front != rear)
	{
		front=(front+1)%MAXSIZE;
		p=qu[front];
		printf("%c ",p->data);
 
		if(p->lchild!=NULL)
		{
			rear=(rear+1)%MAXSIZE;
			qu[rear]=p->lchild;
		}
 
		if(p->rchild!=NULL)
		{
			rear=(rear+1)%MAXSIZE;
			qu[rear]=p->rchild;
		}
	}
}

int count(BiTree T) // 计算叶子结点的个数 
{
    if(T==NULL)    return 0;
    int cnt=0;
    if((!T->lchild)&&(!T->rchild))
    {
        cnt++;
    }
    int leftcnt=count(T->lchild);
    int rightcnt=count(T->rchild);
    cnt+=leftcnt+rightcnt;
    return cnt;
}
/*求二叉树结点总数*/
int Count(BiTree T)
{
    if(T==NULL)
        return 0;                   /*空二叉树结点数为0*/
    else                            /*左右子树结点总数加1*/
        return Count(T->lchild)+Count(T->rchild)+1;
}

int Depth(BiTree T) // 计算二叉树的深度 
{
    if(T==NULL)    return 0;
    else
    {
        int m=Depth(T->lchild);
        int n=Depth(T->rchild);
        return m>n?(m+1):(n+1);
    }
}

void exchange(BiTree T,BiTree &NewT) // 交换左右子树 
{
    if(T==NULL)
    {
        NewT=NULL;
        return ;
    }
    else
    {
        NewT=(BiTNode *)malloc(sizeof(BiTNode));
        NewT->data=T->data;
        exchange(T->lchild,NewT->rchild); // 复制原树的左子树给新树的右子树 
        exchange(T->rchild,NewT->lchild); // 复制原树的右子树给新树的左子树 
    }
}

int main()
{
    puts("**************************");
    puts("1. 建立二叉树"); 
    puts("2. 先序遍历二叉树");
    puts("3. 中序遍历二叉树");
    puts("4. 后序遍历二叉树");
	puts("5. 层次遍历二叉树"); 
    puts("6. 计算叶子结点个数"); 
	puts("7. 计算结点总数");
    puts("8. 计算二叉树的深度"); 
    puts("9. 交换二叉树的左右子树"); 
    puts("0. 退出");
    puts("**************************");
    BiTree Tree,NewTree;
    int choose;
    while(~scanf("%d",&choose),choose)
    {
        switch(choose)
        {
            case 1:
                puts("温馨提醒：输入请以 '#' 为左/右子树空的标志!"); 
                CreateBiTree(Tree);
                break;
            case 2:
                printf("先序遍历结果为："); 
                travel1(Tree);
                puts("");
                break;
            case 3:
                printf("中序遍历结果为："); 
                travel2(Tree);
                puts("");
                break;
            case 4:
                printf("后序遍历结果为："); 
                travel3(Tree);
                puts("");
                break;
			case 5:
                printf("层次遍历结果为："); 
                LevelOrder(Tree);
                puts("");
                break;
            case 6:
                printf("叶子结点个数为：%d\n",count(Tree));
                break;
			case 7:
                printf("总结点个数为：%d\n",Count(Tree));
                break;
            case 8:
                printf("二叉树的深度为：%d\n",Depth(Tree));
                break;
            case 9:
                exchange(Tree,NewTree);
                Tree=NewTree;
                puts("交换成功！\n"); 
                break;
        }
    }
    system("pause");
    return 0;
}
/* 
测试数据： abc##de#g##f###
*/

实验结果： 

心得体会：

二叉树是一种非常重要的数据结构，很多其他数据机构都是基于二叉树的基础演变过来的。二叉树有前、中、后三种遍历方式，因为树的本身就是用递归定义的，因此采用递归的方法实现三种遍历，不仅代码简洁且容易理解，但其开销也比较大，而若采用非递归方法实现三种遍历，则要用栈来模拟实现（递归也是用栈实现的）。通过此次试验加深了对二叉树的认识，掌握了二叉树的简单实现，再次认识到计算机专业实践的重要性。下面简单对编码过程中遇到的二叉树的非递归遍历进行简单的思考总结。

1、前序遍历的非递归实现 

非递归的实现思路如下：

对于任一节点P，

1）输出节点P，然后将其入栈，再看P的左孩子是否为空；

2）若P的左孩子不为空，则置P的左孩子为当前节点，重复1）的操作；

3）若P的左孩子为空，则将栈顶节点出栈，但不输出，并将出栈节点的右孩子置为当前节点，看其是否为空；

4）若不为空，则循环至1）操作；

5）如果为空，则继续出栈，但不输出，同时将出栈节点的右孩子置为当前节点，看其是否为空，重复4）和5）操作；

6）直到当前节点P为NULL并且栈空，遍历结束。