/************************************************************************/
二叉树在C语言中的实现与应用
/************************************************************************/
#include
#include
#define STACK_MAX_SIZE 30
#define QUEUE_MAX_SIZE 30
#ifndef elemType
typedef char elemType;
#endif
/************************************************************************/
/* 以下是关于二叉树操作的11个简单算法 */
/************************************************************************/ struct BTreeNode{
elemType data;
struct BTreeNode *left;
struct BTreeNode *right;
};
/* 1.初始化二叉树 */
void initBTree(struct BTreeNode* *bt)
{
*bt = NULL;
return;
}
/* 2.建立二叉树(根据a所指向的二叉树广义表字符串建立) */
void createBTree(struct BTreeNode* *bt, char *a)
{
struct BTreeNode *p;
struct BTreeNode *s[STACK_MAX_SIZE];/* 定义s数组为存储根结点指针的栈使用 */
int top = -1; /* 定义top作为s栈的栈顶指针，初值为-1,表示空栈 */
int k; /* 用k作为处理结点的左子树和右子树，k = 1处理左子树，k = 2处理右子树 */ int i = 0; /* 用i扫描数组a中存储的二叉树广义表字符串，初值为0 */
*bt = NULL; /* 把树根指针置为空，即从空树开始建立二叉树 */
/* 每循环一次处理一个字符，直到扫描到字符串结束符\0为止 */
while(a[i] != '\0'){
switch(a[i]){
case ' ':
break; /* 对空格不作任何处理 */
case '(':
if(top == STACK_MAX_SIZE - 1){
printf("栈空间太小！\n");
exit(1);
}
top++;
s[top] = p;
k = 1;
break;
case ')':
if(top == -1){
printf("二叉树广义表字符串错误!\n");
exit(1);
}
top--;
break;
case ',':
k = 2;
break;
default:
p = new BTreeNode ;
p->data = a[i];
p->left = p->right = NULL;
if(*bt == NULL){
*bt = p;
}else{
if( k == 1){
s[top]->left = p;
}else{
s[top]->right = p;
}
}
}
i++; /* 为扫描下一个字符修改i值 */
}
return;
}
/* 3.检查二叉树是否为空，为空则返回1,否则返回0 */ int emptyBTree(struct BTreeNode *bt)
{
if(bt == NULL){
return 1;
}else{
return 0;
}
}
/* 4.求二叉树深度 */
int BTreeDepth(struct BTreeNode *bt)
{
if(bt == NULL){
return 0; /* 对于空树，返回0结束递归 */
}else{
int dep1 = BTreeDepth(bt->left); /* 计算左子树的深度 */
int dep2 = BTreeDepth(bt->right); /* 计算右子树的深度 */
if(dep1 > dep2){
return dep1 + 1;
}else{
return dep2 + 1;
}
}
}
/* 5.从二叉树中查找值为x的结点，若存在则返回元素存储位置，否则返回空值 */ elemType *findBTree(struct BTreeNode *bt, elemType x)
{
if(bt == NULL){
return NULL;
}else{
if(bt->data == x){
return &(bt->data);
}else{ /* 分别向左右子树递归查找 */
elemType *p;
if(p = findBTree(bt->left, x)){
return p;
}
if(p = findBTree(bt->right, x)){
return p;
}
return NULL;
}
}
}
/* 6.输出二叉树(前序遍历) */
void printBTree(struct BTreeNode *bt)
{
/* 树为空时结束递归，否则执行如下操作 */
if(bt != NULL){
printf("%c", bt->data); /* 输出根结点的值 */
if(bt->left != NULL || bt->right != NULL){
printf("(");
printBTree(bt->left);
if(bt->right != NULL){
printf(",");
}
printBTree(bt->right);
printf(")");
}
}
return;
}
/* 7.清除二叉树，使之变为一棵空树 */
void clearBTree(struct BTreeNode* *bt) {
if(*bt != NULL){
clearBTree(&((*bt)->left));
clearBTree(&((*bt)->right));
free(*bt);
*bt = NULL;
}
return;
}
/* 8.前序遍历 */
void preOrder(struct BTreeNode *bt)
{
if(bt != NULL){
printf("%c ", bt->data); /* 访问根结点 */ preOrder(bt->left); /* 前序遍历左子树 */ preOrder(bt->right); /* 前序遍历右子树 */ }
return;
}
/* 9.前序遍历 */
void inOrder(struct BTreeNode *bt)
{
if(bt != NULL){
inOrder(bt->left); /* 中序遍历左子树 */ printf("%c ", bt->data); /* 访问根结点 */ inOrder(bt->right); /* 中序遍历右子树 */ }
return;
}
/* 10.后序遍历 */
void postOrder(struct BTreeNode *bt)
{
if(bt != NULL){
postOrder(bt->left); /* 后序遍历左子树 */ postOrder(bt->right); /* 后序遍历右子树 */ printf("%c ", bt->data); /* 访问根结点 */ }
return;
}
/* 11.按层遍历 */
void levelOrder(struct BTreeNode *bt)
{
struct BTreeNode *p;
struct BTreeNode *q[QUEUE_MAX_SIZE];
int front = 0, rear = 0;
/* 将树根指针进队 */
if(bt != NULL){
rear = (rear + 1) % QUEUE_MAX_SIZE;
q[rear] = bt;
}
while(front != rear){ /* 队列非空 */
front = (front + 1) % QUEUE_MAX_SIZE; /* 使队首指针指向队首元素 */
p = q[front];
printf("%c ", p->data);
/* 若结点存在左孩子，则左孩子结点指针进队 */
if(p->left != NULL){
rear = (rear + 1) % QUEUE_MAX_SIZE;#include
#include
#define STACK_MAX_SIZE 30
#define QUEUE_MAX_SIZE 30
#ifndef elemType
typedef char elemType ;
#endif
/************************************************************************/
/* 以下是关于二叉树操作的11个简单算法 */
/************************************************************************/
struct BTreeNode{
elemType data ;
struct BTreeNode *left ;
struct BTreeNode *right ;
};
/* 1.初始化二叉树 */
void initBTree(struct BTreeNode* *bt)
{
*bt = NULL ;
return ;
}
/* 2.建立二叉树(根据a所指向的二叉树广义表字符串建立) */
void createBTree(struct BTreeNode* *bt, char *a)
{
struct BTreeNode *p;
struct BTreeNode *s[STACK_MAX_SIZE];/* 定义s数组为存储根结点指针的栈使用 */
int top = -1; /* 定义top作为s栈的栈顶指针，初值为-1,表示空栈 */
int k ; /* 用k作为处理结点的左子树和右子树，k = 1处理左子树，k = 2处理右子树 */ int i = 0 ; /* 用i扫描数组a中存储的二叉树广义表字符串，初值为0 */
*bt = NULL ; /* 把树根指针置为空，即从空树开始建立二叉树 */
/* 每循环一次处理一个字符，直到扫描到字符串结束符\0为止 */ while(a[i] != '\0')
{
switch(a[i])
{
case ' ':
break; /* 对空格不作任何处理 */
case '(':
if( top == STACK_MAX_SIZE - 1 )
{
printf("栈空间太小！\n") ;
exit(1) ;
}
top++ ;
s[top] = p ;
k = 1 ;
break;
case ')':
if(top == -1){
printf("二叉树广义表字符串错误!\n");
exit(1);
}
top-- ;
break ;
case ',':
k = 2;
break;
default:
p = new BTreeNode ;
p->data = a[i] ;
p->left = p->right = NULL ;
if( *bt == NULL){
*bt = p ;
}
else{
if( k == 1){
s[top]->left = p ;
}
else{
s[top]->right = p ;
}
}
}
i++ ; /* 为扫描下一个字符修改i值 */
}
return;
}
/* 3.检查二叉树是否为空，为空则返回1,否则返回0 */
int emptyBTree(struct BTreeNode *bt)
{
if(bt == NULL){
return 1;
}
else{
return 0;
}
}
/* 4.求二叉树深度 */
int BTreeDepth(struct BTreeNode *bt)
{
if(bt == NULL){
return 0; /* 对于空树，返回0结束递归 */
}
else{
int dep1 = BTreeDepth(bt->left); /* 计算左子树的深度 */
int dep2 = BTreeDepth(bt->right); /* 计算右子树的深度 */
if(dep1 > dep2){
return dep1 + 1;
}
else{
return dep2 + 1;
}
}
}
/* 5.从二叉树中查找值为x的结点，若存在则返回元素存储位置，否则返回空值 */ elemType *findBTree(struct BTreeNode *bt, elemType x)
{
if(bt == NULL){
return NULL;
}
else{
if(bt->data == x){
return &(bt->data);
}
else{ /* 分别向左右子树递归查找 */
elemType *p ;
if(p = findBTree(bt->left, x)){
return p ;
}
if(p = findBTree(bt->right, x)){
return p ;
}
return NULL ;
}
}
}
/* 6.输出二叉树(前序遍历) */
void printBTree(struct BTreeNode *bt)
{
/* 树为空时结束递归，否则执行如下操作 */
if(bt != NULL)
{
printf("%c ", bt->data); /* 输出根结点的值 */ if(bt->left != NULL || bt->right != NULL)
{
printf("(") ;
printBTree(bt->left) ;
if(bt->right != NULL)
{
printf(",") ;
}
printBTree(bt->right) ;
printf(")");
}
}
return;
}
/* 7.清除二叉树，使之变为一棵空树 */
void clearBTree(struct BTreeNode* *bt)
{
if(*bt != NULL){
clearBTree(&((*bt)->left)) ;
clearBTree(&((*bt)->right)) ;
free(*bt) ;
*bt = NULL ;
}
return ;
}
/* 8.前序遍历 */
void preOrder(struct BTreeNode *bt)
{
if(bt != NULL){
printf("%c ", bt->data) ; /* 访问根结点 */ preOrder(bt->left) ; /* 前序遍历左子树 */ preOrder(bt->right) ; /* 前序遍历右子树 */
}
return ;
}
/* 9.中序遍历 */
void inOrder(struct BTreeNode *bt)
{
if(bt != NULL){
inOrder(bt->left); /* 中序遍历左子树 */
printf("%c ", bt->data); /* 访问根结点 */
inOrder(bt->right); /* 中序遍历右子树 */
}
return;
}
/* 10.后序遍历 */
void postOrder(struct BTreeNode *bt)
{
if(bt != NULL){
postOrder(bt->left); /* 后序遍历左子树 */
postOrder(bt->right); /* 后序遍历右子树 */
printf("%c ", bt->data); /* 访问根结点 */
}
return;
}
/* 11.按层遍历 */
void levelOrder(struct BTreeNode *bt)
{
struct BTreeNode *p;
struct BTreeNode *q[QUEUE_MAX_SIZE];
int front = 0, rear = 0;
/* 将树根指针进队 */
if(bt != NULL){
rear = (rear + 1) % QUEUE_MAX_SIZE;
q[rear] = bt;
}
while(front != rear){ /* 队列非空 */
front = (front + 1) % QUEUE_MAX_SIZE; /* 使队首指针指向队首元素 */ p = q[front];
printf("%c ", p->data);
/* 若结点存在左孩子，则左孩子结点指针进队 */
if(p->left != NULL){
rear = (rear + 1) % QUEUE_MAX_SIZE;
q[rear] = p->left;
}
/* 若结点存在右孩子，则右孩子结点指针进队 */
if(p->right != NULL){
rear = (rear + 1) % QUEUE_MAX_SIZE;
q[rear] = p->right;
}
}
return;
}
/************************************************************************/
int main(int argc, char *argv[])
{
struct BTreeNode *bt ; /* 指向二叉树根结点的指针 */
char *b ; /* 用于存入二叉树广义表的字符串 */
elemType x, *px ;
initBTree(&bt) ;
printf("输入二叉树广义表的字符串：\n") ;
/* scanf("%s", b); */
b = "a(b(c), d(e(f, g), h(, i)))" ; //////其中不在括号中的字符表示的是根节点括号中的分别是左右儿子
createBTree(&bt, b) ;
if(bt != NULL)
printf(" %c ", bt->data) ;
printf("以广义表的形式输出：\n") ;
printBTree(bt); /* 以广义表的形式输出二叉树 */
printf("\n");
printf("前序："); /* 前序遍历 */
preOrder(bt);
printf("\n");
printf("中序："); /* 中序遍历 */
inOrder(bt);
printf("\n");
printf("后序："); /* 后序遍历 */
postOrder(bt);
printf("\n");
printf("按层："); /* 按层遍历 */
levelOrder(bt);
printf("\n");
/* 从二叉树中查找一个元素结点 */
printf("输入一个待查找的字符：\n");
scanf(" %c", &x); /* 格式串中的空格跳过空白字符 */
px = findBTree(bt, x);
if(px){
printf("查找成功：%c\n", *px);
}else{
printf("查找失败！\n");
}
printf("二叉树的深度为：");
printf("%d\n", BTreeDepth(bt));
clearBTree(&bt);
return 0;
}
#include
{ inorder(p->lchild); printf("%c ",p->data); inorder(p->rchild); } } void postorder(TREE *p) //后序遍历 { if (p!=NULL) { postorder(p->lchild); postorder(p->rchild); printf("%c ",p->data); } } void shu(TREE *p,int len) //数的形状{ if (p!=NULL) { shu(p->lchild,len+1); for (int i=1;i<=4*len;i++) { printf(" "); } printf("%c",p->data); printf("------\n"); shu(p->rchild,len+1); } } int shendu(TREE *p) //计算深度 { int l,r; if (p==NULL) { return 0; } l=shendu(p->lchild)+1; r=shendu(p->rchild)+1; if (l>=r) //左右子树比较return l; else
内蒙古科技大学 本科生课程设计说明书 题目：数据结构课程设计 ——二叉树的遍历和应用 学生姓名： 学号： 专业： 班级： 指导教师： 2013年5月29日
内蒙古科技大学课程设计说明书 内蒙古科技大学课程设计任务书 I
内蒙古科技大学课程设计说明书 目录 内蒙古科技大学课程设计任务书..............................................................错误！未定义书签。目录....................................................................................................................................II 第一章需求分析 (3) 1.1课程设计目的 (3) 1.2任务概述 (3) 1.3课程设计内容 (3) 第二章概要设计 (5) 2.1设计思想 (5) 2.2二叉树的遍历 (5) 2.3运行界面设计 (6) 第三章详细设计 (7) 3.1二叉树的生成 (7) 3.2二叉树的先序遍历 (7) 3.3 二叉树的中序遍历 (8) 3.4二叉树的后续遍历 (8) 3.5主程序的设计 (8) 第四章测试分析 (11) 4.1二叉树的建立 (11) 4.2二叉树的先序、中序、后序遍历 (11) 第五章课程设计总结 (12) 附录：程序代码 (13) 致谢 ···········································································································错误！未定义书签。 II
实验课题一：将下图中得二叉树用二叉链表表示： 1用三种遍历算法遍历该二叉树，给出对应得输出结果; 2写一个函数对二叉树搜索,若给出一个结点，根据其就是否属于该树，输出tｒｕe或者f ａｌse。 3写函数完成习题4、31(Ｃ＋+版)或4、2８（C版教科书）。 #iｎclｕde "stdio、h＂ ＃incluｄe”mallｏc、h" typedｅfｓtruct BｉTＮode ｛ cｈar data; sｔrucｔBiTＮode *lｃｈild,*rｃhiｌd; }ＢiTＮodｅ，*BiTrｅe； BｉＴree Creaｔe（BｉTｒeｅT) ｛ char ch； ch=getchａｒ(）; ｉｆ(ch=='#’） T=NULL; elｓe { T=(BiＴNode *）maｌloc(sｉｚｅｏf（ＢiTNｏｄe)）; Ｔ-〉data=ｃh； Ｔ-＞lｃｈiｌd=Creaｔe(T—〉lchilｄ); T—〉rchild=Creａte(Ｔ－〉rchｉld）； ｝ retuｒn Ｔ； } ｉnt node(BiＴrｅe Ｔ) { int sum1=0，a,b; ?iｆ（T) ｛ if（Ｔ！=ＮUＬL） ??sｕm1++;
?ａ=ｎode（Ｔ->lchiｌd); sｕm1＋=ａ； b=node(T—>rchｉld)； sum1+=b; ?} ｒetｕrn sum1； } int mｎode（BiTree T） { ?int sum２=0,ｅ，ｆ； if（T) { ?ｉf（（T->lcｈiｌd!=NULL）&＆(T－〉rchild!=NULL）)?sum2++； ?e=ｍnoｄｅ（Ｔ－〉lchild); suｍ2＋=e; f＝mnoｄｅ（T－〉rchｉｌd)； sum２+=f； ?｝ retｕrn sum2; ｝ void Preorｄer（BiTree T) { ｉf(Ｔ） { pｒintf（＂%c”，T－>daｔa)； Ｐreoｒder(Ｔ—>lchiｌｄ）； Ｐreorder（T－〉rchｉld）； ｝ } iｎt Sumｌeaｆ（BiTｒｅe T) { int suｍ=0,m，n; if（T） { if((！T-〉lchild）&&（!T-〉rｃhiｌd)) sum++； m=Ｓuｍleaf（T－>lchｉld)； suｍ+=m； n=Sumleaf(T—＞rｃhｉｌd); suｍ+＝ｎ； ｝ retuｒn ｓum； }
目录 一．选题背景 (1) 二．问题描述 (1) 三．概要设计 (2) 3.1.创建二叉树 (2) 3.2.二叉树的非递归前序遍历示意图 (2) 3.3.二叉树的非递归中序遍历示意图 (2) 3.4.二叉树的后序非递归遍历示意图 (3) 四．详细设计 (3) 4.1创建二叉树 (3) 4.2二叉树的非递归前序遍历算法 (3) 4.3二叉树的非递归中序遍历算法 (4) 4.4二叉树的非递归后序遍历算法 (5) 五．测试数据与分析 (6) 六．源代码 (6) 总结 (10) 参考文献: (11)
一．选题背景 二叉树的链式存储结构是用指针建立二叉树中结点之间的关系。二叉链存储结构的每个结点包含三个域，分别是数据域，左孩子指针域，右孩子指针域。因此每个结点为 由二叉树的定义知可把其遍历设计成递归算法。共有前序遍历、中序遍历、后序遍历。可先用这三种遍历输出二叉树的结点。 然而所有递归算法都可以借助堆栈转换成为非递归算法。以前序遍历为例，它要求首先要访问根节点，然后前序遍历左子树和前序遍历右子树。特点在于所有未被访问的节点中，最后访问结点的左子树的根结点将最先被访问，这与堆栈的特点相吻合。因此可借助堆栈实现二叉树的非递归遍历。将输出结果与递归结果比较来检验正确性。。 二．问题描述 对任意给定的二叉树（顶点数自定）建立它的二叉链表存贮结构，并利用栈的五种基本运算（置空栈、进栈、出栈、取栈顶元素、判栈空）实现二叉树的先序、中序、后序三种遍历，输出三种遍历的结果。画出搜索顺序示意图。
三．概要设计 3.1.创建二叉树 3.2.二叉树的非递归前序遍历示意图 图3.2二叉树前序遍历示意图3.3.二叉树的非递归中序遍历示意图 图3.3二叉树中序遍历示意图
#include "stdio.h" #include "stdlib.h" #define STACK_INIT_SIZE 100 //栈存储空间初始分配量 #define STACKINCREMENT 10 //存储空间分配增量 //------二叉树的存储结构表示------// typedef struct BiTNode{ int data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; //-----顺序栈的存储结构表示------// typedef struct{ BiTree *top; BiTree *base; int stacksize; }SqStack; //*************************************************** //构造一个空栈s SqStack *InitStack(); //创建一颗二叉树 BiTree CreatBiTree(); //判断栈空 int StackEmpty(SqStack *S); //插入元素e为新的栈顶元素 void Push(SqStack *S,BiTree p); //若栈不为空，则删除s栈顶的元素e，将e插入到链表L中void Pop(SqStack *S,BiTree *q); //非递归先序遍历二叉树 void PreOrderTraverse(BiTree L); //非递归中序遍历二叉树 void InOrderTraverse(BiTree L); //非递归后序遍历二叉树 void PostOrderTraverse(BiTree L); //递归后序遍历二叉树 void PostOrder(BiTree bt); //递归中序遍历二叉树 void InOrder(BiTree bt); //递归先序遍历二叉树 void PreOrder(BiTree bt); //***************************************************
C语言实现二叉树的前序遍历算法实现一： #include
#include
江南大学通信与控制工程学院标准实验报告 （实验）课程名称：计算机软件技术基础实验名称：二叉树的遍历和应用 班级：自动化 姓名：李玉书 学号：03 指导教师：卢先领 江南大学通信与控制学院
江南大学 实验报告 学生姓名：张晓蔚学号：0704090304 实验地点：信控机房实验时间：90分钟 一、实验室名称：信控学院计算中心 二、实验项目名称：二叉树的遍历和应用 三、实验学时：4学时 四、实验原理： 二叉树的遍历和应用 五、实验目的： 1、掌握二叉树的数据类型描述及特点。 2、掌握二叉树的存储结构（二叉链表）的建立算法。 3、掌握二叉链表上二叉树的基本运算的实现。 六、实验内容： 阅读后面的程序，并将其输入到计算机中，通过调试为下面的二叉树建立二叉链表，并用递归实现二叉树的先序、中序、后序三种遍历。 七、实验器材（设备、元器件）： 计算机 八、实验步骤： 1、输入示例程序 2、构建按序插入函数实现算法 3、用C语言实现该算法 4、与源程序合并，编译，调试 5、测试，查错，修改
6、生成可执行文件，通过综合测试，完成实验 九、实验数据及结果分析： 测试用例 初始数据：ABDH,,I,,EJ,,K,,CFL,,,G,, 测试结果 十、实验结论： 该程序可以完成线性表的常规功能，且增加了异常处理，在异常情况下，例如： 表空，删除结点号不合法或出界，删除数值未找到等，这些情况下都能作出处理。可以通过边界测试。 十一对本实验过程及方法、手段的改进建议： 对书中程序的几点错误做了改正，见源程序。 附：源程序 #include
1,2两问的程序代码如下： #include "stdio.h" #include"malloc.h" typedef struct BiTNode { char data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; BiTree Create(BiTree T) { char ch; ch=getchar(); if(ch=='#') T=NULL; else { T=(BiTNode *)malloc(sizeof(BiTNode)); T->data=ch; T->lchild=Create(T->lchild); T->rchild=Create(T->rchild); } return T; } int node(BiTree T) { int sum1=0,a,b;
if(T) { if(T!=NULL) sum1++; a=node(T->lchild); sum1+=a; b=node(T->rchild); sum1+=b; }
return sum1; } int mnode(BiTree T) { int sum2=0,e,f; if(T) { if((T->lchild!=NULL)&&(T->rchild!=NULL)) sum2++; e=mnode(T->lchild); sum2+=e; f=mnode(T->rchild); sum2+=f; } return sum2;
void Preorder(BiTree T) { if(T) { printf("%c",T->data); Preorder(T->lchild); Preorder(T->rchild); } } int Sumleaf(BiTree T) { int sum=0,m,n; if(T) { if((!T->lchild)&&(!T->rchild)) sum++; m=Sumleaf(T->lchild); sum+=m; n=Sumleaf(T->rchild); sum+=n; } return sum; } void zhongxu(BiTree T) {
实验8 二叉树的遍历与应用 一、实验目的 1.进一步掌握指针变量的含义。 2.掌握二叉树的结构特征，理解并熟悉掌握创建二叉树和实现二叉树的三种遍历。 3.学会编写实现二叉树基本操作的递归算法，领会递归的实质。 二、实验要求 1. 给出程序设计的基本思想、原理和算法描述。 2. 源程序给出注释。 3. 保存和打印出程序的运行结果，并结合程序进行分析。 三、实验题目 1.编写算法，按层输出一棵顺序存储的二叉树所有结点的值。 /**********level.c************/ #include
实验二叉树遍历算法及应用 实验报告二叉树的遍历应用算法测试实验日期:______________ 学生姓 名:______________ 班级:_______________ 一、实习目的: 1、深入了解二叉树的存储结构及二叉树的遍历方法; 2、掌握二叉树的遍历算法及应用。 二、实习内容及要求 ----------------------------------------------------------------------------------------------------------------------------------------- 应用遍历思想，建立一棵如下图所示的二叉树，并能够完成如下操作: 1. 输出该二叉树的先序、中序、后序遍历序列; 2. 拷贝该树，生成一棵新树; 3. 将原树拆分成左右2棵树，并分别输出该二叉树左子树的遍历序列和右子树的遍历序列; 4. 利用遍历算法输出复制生成的树中结点总数、叶子总数、二叉树高度，并能够输出此二叉树中的叶子 结点。 ----------------------------------------------------------------------------------------------------------------------------------------- 附加:应用二叉树的顺序存储结构，实现建树。 并设计一个算法，实现能够输入一棵树中的双亲结点，输出该双亲结点的所有孩子结点的算法。
三、数据结构设计 (请将数据结构设计填写在此部分。) 四、测试 分别给出以下三棵树的测试结果
#include
if(p->lchild!=NULL) inorder(p->lchild); printf("%c",p->data); if(p->rchild!=NULL) inorder(p->rchild); } } void postorder(bitree &p) { if(p) { if(p->lchild!=NULL) postorder(p->lchild); if(p->rchild!=NULL) postorder(p->rchild); printf("%c",p->data); } } int number(bitree &bt){ int n1,n2; if(!bt)return 0; if(!bt->lchild&&!bt->rchild) return 1; n1=number(bt->lchild); n2=number(bt->rchild); return(n1+n2+1); } int leafs(bitree &bt){ int n1,n2; if(!bt) return 0; if(!bt->lchild&&!bt->rchild) return 1; n1=leafs(bt->lchild); n2=leafs(bt->rchild); return n1+n2; } int height(bitree &bt){ int h1,h2; if(!bt) return 0;
二叉树的遍历实验报告 一、需求分析 在二叉树的应用中，常常要求在树中查找具有某种特征的结点，或者对树中全部结点逐一进行某种处理，这就是二叉树的遍历问题。 对二叉树的数据结构进行定义，建立一棵二叉树，然后进行各种实验操作。 二叉树是一个非线性结构，遍历时要先明确遍历的规则，先访问根结点还时先访问子树，然后先访问左子树还是先访问有右子树，这些要事先定好，因为采用不同的遍历规则会产生不同的结果。本次实验要实现先序、中序、后序三种遍历。 基于二叉树的递归定义，以及遍历规则，本次实验也采用的是先序遍历的规则进行建树的以及用递归的方式进行二叉树的遍历。 二、系统总框图
三、各模块设计分析 （1）建立二叉树结构 建立二叉树时，要先明确是按哪一种遍历规则输入，该二叉树是按你所输入的遍历规则来建立的。本实验用的是先序遍历的规则进行建树。 二叉树用链表存储来实现，因此要先定义一个二叉树链表存储结构。因此要先定义一个结构体。此结构体的每个结点都是由数据域data 、左指针域Lchild 、右指针域Rchild 组成，两个指针域分别指向该结点的左、右孩子，若某结点没有左孩子或者右孩子时，对应的指针域就为空。最后，还需要一个链表的头指针指向根结点。 要注意的是，第一步的时候一定要先定义一个结束标志符号，例如空格键、＃等。当它遇到该标志时，就指向为空。 建立左右子树时，仍然是调用create （）函数，依此递归进行下去，
直到遇到结束标志时停止操作。 （2）输入二叉树元素 输入二叉树时，是按上面所确定的遍历规则输入的。最后，用一个返回值来表示所需要的结果。 （3）先序遍历二叉树 当二叉树为非空时，执行以下三个操作：访问根结点、先序遍历左子树、先序遍历右子树。 （4）中序遍历二叉树 当二叉树为非空时，程序执行以下三个操作：访问根结点、先序遍历左子树、先序遍历右子树。 （5）后序遍历二叉树 当二叉树为非空时，程序执行以下三个操作：访问根结点、先序遍历左子树、先序遍历右子树。 （6）主程序 需列出各个函数，然后进行函数调用。 四、各函数定义及说明 因为此二叉树是用链式存储结构存储的，所以定义一个结构体用以存储。 typedef struct BiTNode { char data; struct BiTNode *Lchild; struct BiTNode *Rchild;
用C语言编写二叉树的建立与遍历 #include "stdio.h" #include "string.h" #define NULL 0 typedef struct BiTNode{ char data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; BiTree Create(BiTree T){ char ch; ch=getchar(); if(ch=='#') T=NULL; else{ if(!(T=(BiTNode *)malloc(sizeof(BiTNode)))) printf("Error!"); T->data=ch; T->lchild=Create(T->lchild); T->rchild=Create(T->rchild); } return T;
} void Preorder(BiTree T){ if(T){ printf("%c",T->data); Preorder(T->lchild); Preorder(T->rchild); } } int Sumleaf(BiTree T){ int sum=0,m,n; if(T){ if((!T->lchild)&&(!T->rchild)) sum++; m=Sumleaf(T->lchild); sum+=m; n=Sumleaf(T->rchild); sum+=n; } return sum; } void zhongxu(BiTree T){ if(T){
zhongxu(T->lchild); printf("%c",T->data); zhongxu(T->rchild); } } void houxu(BiTree T){ if(T){ houxu(T->lchild); houxu(T->rchild); printf("%c",T->data); } } int Depth(BiTree T){ int dep=0,depl,depr; if(!T) dep=0; else{ depl=Depth(T->lchild); depr=Depth(T->rchild); dep=1+(depl>depr?depl:depr); } return dep; }
实验报告 题目：二叉树的遍历及应用 院系：数学系 专业：数学与应用数学 学号： 2010114036 姓名：郭奇瑞
一、实验名称：二叉树的遍历及应用 二、实验日期：2012年11月14日 三、实验要求：编程实现二叉树的建立并对其进行遍历 四、实验目的： 1、掌握二叉树链式存储结构的类型定义及实现； 2、掌握二叉树链式存储结构的各类基本运算方法； 3、掌握二叉树各个重要性质在解决实际问题中的应用； 4、掌握二叉树的分析方法、解决方法，从而提高实际编程能 力及程序调试能力。 五、实验内容 1、创建二叉树； 2、用递归方法实现二叉树的各种遍历。 六、程序代码 #include
struct Node *RChild; }BiTNode,*BiTree; typedef BiTree StackElementType; typedef struct { StackElementType elem[Stack_Size]; int top; }SeqStack; //初始化 void InitStack(SeqStack *S) { S->top=-1; } //进栈 int Push(SeqStack *S,StackElementType x) { if(S->top==Stack_Size-1) return(FALSE); S->top++; S->elem[S->top]=x; return(TRUE); }
二叉树的遍历及其应用 摘要：二叉树是一种特殊的树，它在计算机科学领域提供了大量的实际应用。二叉树依照需求可以通过阵列以及链接链表来实现。树的遍历是指一次访问树的所有节点的过程。遍历二叉树有三种方式，分别是先序遍历，中序遍历，后序遍历。在遍历的过程中更加深入的了解二叉树遍历的算法过程及其应用，以至于充分的认识到二叉树遍历的优越性。 关键词：二叉树，遍历，先序遍历，中序遍历，后序遍历 Traversing a binary tree and its application Abstract:A binary tree is a special type of tree that offers a lot of practical applications in the field of computer science.Binary trees can be implemented by using arrays as well as linked lists,depending upon the requirements. Traversing a tree refers to the process of visiting all the nodes of the tree once.There are three ways in which you can traverse a binary tree.They are inorder,preorder,and postorder traversal. In the process of binary,I deeply realise the arithmetic process and theappliance of binary.I also realise the superiority of traversing a binary tree. Key words:binary tree; traversal;inorder traversal; preorder traversal; postorder traversal 0引言 所谓遍历，是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题。遍历在二叉树上最重要的运算之一，是二叉树上进行其它运算之基础。二叉树作为一种重要的数据结构是工农业应用与开发的重要工具。遍历是二叉树算法设计中经典且永恒的话题。经典的算法大多采用递归搜索。递归算法具有简练、清晰等优点，但因其执行过程涉及到大量的堆栈使用，难于应用到一些严格限制堆栈使用的系统，也无法应用到一些不支持递归的语言环境[9]。 1遍历二叉树的概念 所谓遍历二叉树，就是遵从某种次序，访问二叉树中的所有结点，使得每个结点仅被访问一次。这里提到的“访问”是指对结点施行某种操作，操作可以是输出结点信息，修改结点的数据值等，但要求这种访问不破坏它原来的数据结构。在本文中，我们规定访问是输出结点信息data，且以二叉链表作为二叉树的存贮结构。由于二叉树是一种非线性结构，每个结点可能有一个以上的直接后继，因此，必须规定遍历的规则,并按此规则遍历二叉树,最后得到二叉树所有结点的一个线性序列[1]。 2二叉树遍历的算法 二叉树的遍历方式有三种：中序遍历、前序遍历、后序遍历。 1、中序遍历的递归算法定义：
摘要 本文设计了一个对数据输入，输出，储存，查找的多功能软件，本文需要保存家族的基本信息，包括姓名及它们的关系，但是由于家族信息很巨大而且关系很复杂所以采用二叉树来表示它们的关系。并且具有保存文件的功能，以便下次直接使用先前存入的信息。家谱的功能是查询家族每个人的信息，并且输出它们的信息，还要具有查询输出功能。 本文采用二叉树来存取家族的基本信息，头结点作为父亲节点，他的左孩子为他的妻子，妻子结点的右孩子为他的孩子，依次存储每个家庭的信息。可以查找每个父亲的孩子和每个人的所有祖先。 关键词：二叉树家谱结点
目录 1 系统功能概述 (1) 1.1 系统功能 (1) 图2 成员二叉树功能模块图 (4) 1.2 总体功能模块 (4) 2 系统各功能模块的详细设计 (4) 2.1功能选择 (4) 2.2信息输入 (6) 2.3信息输出 (7) 2.4信息存盘 (7) 2.5信息清盘 (8) 2.6信息查询 (8) 2.7源程序 (10) 3设计结果与分析 (16) 3.1菜单函数功能测试 (16) 4.2输入功能函数测试 (16) 3.3输出功能函数测试 (17) 3.4清盘功能函数测试 (17) 3.5存盘功能函数测试 (17) 3.6查询功能函数测试 (18) 总结 (19) 参考文献 (20)
1 系统功能概述 1.1 系统功能 实现的方法是先定义一个二叉树，该二叉树上的每个结点由三个元素组成：姓名、指向它左孩子的指针、以及指向它右孩子的指针构成。该家谱管理系统将信息用文件的方法进行存储管理，再从文件中将成员信息以递归的方法创建二叉树。该输入成员信息的方法是将父亲结点存上父亲的信息，然后父亲结点的左孩子存上母亲的信息，母亲结点的右孩子存上孩子的信息。 (1)定义结构体 结构体为表示一个对象的不同属性提供了连贯一致的方法，结构体类型的说明从关键词struct开始，成员可以由各种数据类型混合构成，成员甚至还可以是数组或者其他类型的结构，但是，结构体中不能包含自身定义类型的成员。本文定义了两个结构体，分别是家族成员和二叉树结点的结构体。代码如下：typedef struct fnode { char father[NAMEWIDTH]; char wife[NAMEWIDTH]; char son[NAMEWIDTH]; }FamType; typedef struct tnode { char name[NAMEWIDTH]; struct tnode *lchild,*rchild; }BTree; (2) 二叉树的建立 二叉树的结点有三个域，数据域和两个指针域，数据域用来存放数据，两个指针域分别存放指向该结点左右孩子的指针。并且还有个root结点，称二叉树的根节点。代码如下： BTree *CreatBTree(char *root,FamType fam[],int n)
实验六二叉树的递归遍历及其应用 一、实验目的 1、深入了解二叉树递归的逻辑结构特征及其基本操作。 2、了解二叉树各种存储结构的特点及其适用范围，熟练掌握二叉树的二叉链表结构的定义及其递归遍历算法、按层次遍历算法的c语言实现，能深入了解递归算法的执行过程。 3、熟练掌握二叉树递归遍历算法的应用。 一、实验内容和要求 2、设计并验证如下算法：与“12.7.4参考源程序”类似，按中序序列输入建立两棵二叉树的二叉链表结构，求双分支结点数，判断两棵树是否相等。 3、设计并验证如下算法：按层次遍历二叉树，打印结点所在的层次，并求该二叉树的宽度。 二、实验过程及结果 （第一题） 一、需求分析 1、从键盘输入二叉树的序列，但由于建树是从根结点往下建立的，故只能输入先 序序列，则按照中序建树完成二叉树的创建。 2、从键盘输入一段正确的序列后，按回车键自动生成二叉树，若该序列不能生成 一颗二叉树，则程序无法继续进行，只能退出。 3、程序能实现的功能包括： ①初始化二叉树；②创建一棵完整二叉树；③先中后序遍历二叉树； ④求二叉树双分支结点数；⑤比较两棵二叉树是否相等； 二、概要设计 1、二叉树的抽象数据类型定义： ADT BinaryTree{ 数据对象D：D是具有相同特征的数据元素的集合。 数据关系R： 若D=空，则R=空，称BinaryTree为空二叉树； 若D！=空，则R={H}，H是如下二元关系： （1）在D中存在唯一的称为根的数据元素root，它在关系H下无前驱； （2）若D-{root}!=Φ，则存在D-{root}={D1,Dr}，且D1∩Dr=Φ； （3）若D1！=Φ，则D1中存在唯一元素x1，
/************************************************************************/ 二叉树在C语言中的实现与应用 /************************************************************************/ #include
《数据结构》第六次实验报告 学生姓名 学生班级 学生学号 指导老师
一、实验内容 1) 采用二叉树链表作为存储结构，完成二叉树的建立，先序、中序和后序 以及按层次遍历的操作，求所有叶子及结点总数的操作。 2) 输出树的深度，最大元，最小元。 二、需求分析 遍历二叉树首先有三种方法，即先序遍历，中序遍历和后序遍历。 递归方法比较简单，首先获得结点指针如果指针不为空，且有左子，从左子递归到下一层，如果没有左子，从右子递归到下一层，如果指针为空，则结束一层递归调用。直到递归全部结束。 下面重点来讲述非递归方法： 首先介绍先序遍历： 先序遍历的顺序是根左右，也就是说先访问根结点然后访问其左子再然后访问其右子。具体算法实现如下：如果结点的指针不为空，结点指针入栈，输出相应结点的数据，同时指针指向其左子，如果结点的指针为空，表示左子树访问结束，栈顶结点指针出栈，指针指向其右子，对其右子树进行访问，如此循环，直至结点指针和栈均为空时，遍历结束。 再次介绍中序遍历： 中序遍历的顺序是左根右，中序遍历和先序遍历思想差不多，只是打印顺序稍有变化。具体实现算法如下：如果结点指针不为空，结点入栈，指针指向其左子，如果指针为空，表示左子树访问完成，则栈顶结点指针出栈，并输出相应结点的数据，同时指针指向其右子，对其右子树进行访问。如此循环直至结点指针和栈均为空，遍历结束。 最后介绍后序遍历： 后序遍历的顺序是左右根，后序遍历是比较难的一种，首先需要建立两个栈，一个用来存放结点的指针，另一个存放标志位，也是首先访问根结点，如果结点的指针不为空，根结点入栈，与之对应的标志位也随之入标志位栈，并赋值0，表示该结点的右子还没有访问，指针指向该结点的左子，如果结点指针为空，表示左子访问完成，父结点出栈，与之对应的标志位也随之出栈，如果相应的标志位值为0，表示右子树还没有访问，指针指向其右子，父结点再次入栈，与之对应的标志位也入栈，但要给标志位赋值为1，表示右子访问过。如果相应的标志位值为1，表示右子树已经访问完成，此时要输出相应结点的数据，同时将结点指针赋值为空，如此循环直至结点指针和栈均为空，遍历结束。 三、详细设计 源代码：