实验2 树的二叉链表表示及其遍历
二叉树的建立与遍历实验报告（c语言编写,附源代码）
二叉树的建立与遍历实验报告（c语言编写,附源代码）二叉树的建立与遍历实验报告级班年月日姓名学号_1．实验题目建立一棵二叉树，并对其进行遍历（先序、中序、后序），打印输出遍历结果。
2．需求分析本程序用VC编写，实现建立一棵二叉树的功能，并对其进行遍历（先序、中序、后序），并且打印输出遍历结果。
①输入的形式和输入值的范围：输入二叉树的先序，当其结点为空时，需要输入#。
（输入的先序仅含字母和#）②输出的形式：输出二叉树的先序、中序、后序。
③程序所能达到的功能：实现建立一棵二叉树的功能，并对其进行遍历（先序、中序、后序），并且打印输出遍历结果。
④测试数据：输入数据：输入ABC##DE#G##F###输出结果：二叉树的先序遍历为：ABCDEGF二叉树的中序遍历为：CBEGDFA二叉树的后序遍历为：CGEFDBA3．概要设计1)为了实现上述程序功能，需要定义二叉链表的抽象数据类型：typedef struct BinaryTreeNode{TElemType data;//二叉树结点中的数据域struct BinaryTreeNode *lchild , *rchild; //二叉树结点的左孩子和右孩子指针}BinaryTreeNode ,*BiTree;基本操作：A.void CreateBinaryTree (BiTree &T)初始条件：无操作结果：建立了二叉树。
B. void PreOrder(BiTree T)初始条件：存在一棵二叉树操作结果：先序遍历二叉树，并且输出先序遍历的结果。
C. void MidOrder(BiTree T)初始条件：存在一棵二叉树操作结果：中序遍历二叉树，并且输出中序遍历的结果。
D. void PostOrder(BiTree T)初始条件：存在一棵二叉树操作结果：后序遍历二叉树，并且输出后序遍历的结果。
程序包含5个函数：○1主函数main()○2先序建立二叉树 void CreateBinaryTree (BiTree &T)○3先序遍历二叉树，并且输出先序遍历的结果void PreOrder(BiTree T);○4中序遍历二叉树，并且输出中序遍历的结果void MidOrder(BiTree T);○5序遍历二叉树，并且输出后序遍历的结果void PostOrder(BiTree T); 各函数间关系如下：主函数main()CreateBinaryTree PreOrder MidOrder PostOrder4．详细设计1)二叉链表的定义typedef struct BinaryTreeNode{定义一个树结点的数据域;定义一个该结点的左孩子指针和右孩子指针;}2)void CreateBinaryTree (BiTree &T)//先序建立二叉树{输入一个字符量;if(输入字符== '#') T指针置值为NULL;else{动态申请一个指向二叉树结构体的指针把输入字符赋值给新指针的数据域data;调用CreateBinaryTree(新指针的lchild成员);调用CreateBinaryTree(新指针的rchild成员);}}3)void PreOrder(BiTree T) //先序遍历二叉树{if(T指针不为NULL){输出T的data域;先序遍历左子树;先序遍历右子树;}}4)void MidOrder(BiTree T) //中序遍历二叉树{if(T指针不为NULL){中序遍历左子树;输出T的data域;中序遍历右子树;}}5)void PostOrder(BiTree T) //中序遍历二叉树{if(T指针不为NULL){后序遍历左子树;后序遍历右子树;输出T的data域;}}5．调试分析在编写程序过程中，我将scanf（”%c”,&ch）中的%c写成%d，程序运行了一段时间没有结果，经过检查，发现了这个错误。
二叉树的遍历实验报告
二叉树的遍历实验报告二叉树的遍历实验报告引言：二叉树是一种常见的数据结构，它由节点和连接节点的边组成。
在实际应用中，我们经常需要对二叉树进行遍历，以便对其中的节点进行访问和操作。
本次实验旨在探索二叉树的遍历算法，并通过实验验证其正确性和效率。
一、二叉树的定义和基本操作二叉树是一种特殊的树结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。
根据节点的访问顺序，二叉树的遍历可以分为前序遍历、中序遍历和后序遍历三种方式。
前序遍历是指先访问根节点，然后按照左子树、右子树的顺序递归地进行遍历；中序遍历是指先按照左子树、根节点、右子树的顺序递归地进行遍历；后序遍历是指先按照左子树、右子树、根节点的顺序递归地进行遍历。
二、实验设计和方法为了验证二叉树的遍历算法的正确性和效率，我们设计了以下实验方案：1. 构建二叉树：我们首先构建一个具有一定规模的二叉树，以模拟实际应用中的情况。
为了方便起见，我们选择随机生成一棵二叉树，并确保其结构合理。
2. 实现遍历算法：我们根据前文所述的遍历方式，实现了相应的遍历算法。
在实现过程中，我们考虑到了递归和迭代两种方式，并分别进行了实验比较。
3. 遍历实验：我们使用不同规模的二叉树进行遍历实验，并记录遍历的结果和所花费的时间。
通过对比不同规模下不同遍历方式的结果和时间，我们可以评估遍历算法的效率和准确性。
三、实验结果和分析在实验中，我们构建了一棵具有1000个节点的二叉树，并分别使用前序、中序和后序遍历算法进行遍历。
通过实验结果的比较，我们得出以下结论：1. 遍历结果的正确性：无论是前序、中序还是后序遍历，我们都能够正确地访问到二叉树中的每个节点。
这表明我们所实现的遍历算法是正确的。
2. 遍历算法的效率：在1000个节点的二叉树中，我们发现中序遍历算法的执行时间最短，后序遍历算法的执行时间最长，前序遍历算法的执行时间居中。
这是因为中序遍历算法在访问节点时可以尽可能地减少递归次数，而后序遍历算法需要递归到最深层才能返回。
二叉树的遍历算法实验报告
二叉树的遍历算法实验报告二叉树的遍历算法实验报告引言：二叉树是计算机科学中常用的数据结构之一，它是由节点组成的层次结构，每个节点最多有两个子节点。
在实际应用中，对二叉树进行遍历是一项重要的操作，可以帮助我们理解树的结构和节点之间的关系。
本文将介绍二叉树的三种遍历算法：前序遍历、中序遍历和后序遍历，并通过实验验证其正确性和效率。
一、前序遍历前序遍历是指先访问根节点，然后按照先左后右的顺序遍历左右子树。
具体的实现可以通过递归或者使用栈来实现。
我们以递归方式实现前序遍历算法，并进行实验验证。
实验步骤：1. 创建一个二叉树，并手动构造一些节点和它们之间的关系。
2. 实现前序遍历算法的递归函数，函数的输入为根节点。
3. 在递归函数中，首先访问当前节点，然后递归调用函数遍历左子树，最后递归调用函数遍历右子树。
4. 调用前序遍历函数，输出遍历结果。
实验结果：经过实验，我们得到了正确的前序遍历结果。
这证明了前序遍历算法的正确性。
二、中序遍历中序遍历是指按照先左后根再右的顺序遍历二叉树。
同样，我们可以使用递归或者栈来实现中序遍历算法。
在本实验中，我们选择使用递归方式来实现。
实验步骤：1. 继续使用前面创建的二叉树。
2. 实现中序遍历算法的递归函数，函数的输入为根节点。
3. 在递归函数中，首先递归调用函数遍历左子树，然后访问当前节点，最后递归调用函数遍历右子树。
4. 调用中序遍历函数，输出遍历结果。
实验结果：通过实验，我们得到了正确的中序遍历结果。
这证明了中序遍历算法的正确性。
三、后序遍历后序遍历是指按照先左后右再根的顺序遍历二叉树。
同样，我们可以使用递归或者栈来实现后序遍历算法。
在本实验中，我们选择使用递归方式来实现。
实验步骤：1. 继续使用前面创建的二叉树。
2. 实现后序遍历算法的递归函数，函数的输入为根节点。
3. 在递归函数中，首先递归调用函数遍历左子树，然后递归调用函数遍历右子树，最后访问当前节点。
4. 调用后序遍历函数，输出遍历结果。
实验2 二叉树的基本操作
北京林业大学实验任务书北京林业大学15学年—16学年第 1 学期数据结构C实验任务书专业名称：实验学时： 4课程名称：数据结构C 任课教师：孟伟实验题目：二叉树的基本操作实验环境： Visual C++ 6.0实验目的：1．掌握二叉树的定义；2．掌握二叉树的基本操作，如建立、前序遍历、中序遍历和后序遍历、结点个数的统计等。
实验内容：用递归的方法实现以下算法：1．以二叉链表表示二叉树，建立一棵二叉树；2．输出二叉树的前序遍历结果；3．输出二叉树的中序遍历结果；4．输出二叉树的后序遍历结果；5．统计二叉树的叶结点个数；6．统计二叉树的结点个数；7．计算二叉树的深度。
8．交换二叉树每个结点的左孩子和右孩子；选做内容设计二叉树的双序遍历(DblOrderTraverse)算法（双需遍历是指对于二叉树的每一个结点来说，先访问这个结点，再按双序遍历它的左子树，然后再一次访问这个结点，接下来按双序遍历它的右子树）。
实验提示：1．统计二叉树的叶结点个数。
int LeafNodeCount(BiTree T ){如果是空树，则叶子个数为0;如果是叶子结点，则叶子结点个数为1（如何表示叶子结点？？？）否则叶结点个数为左子树的叶结点个数+右子树的叶结点个数}2．计算二叉树的深度。
int Depth(BiTree T){如果是空树，则深度为0;否则(1)计算左子树的深度记为m；(2)计算右左子树的深度记为n；二叉树的深度为m 与n的较大者加1}实验要求：(1) 程序要具在一定的健壮性，即当输入数据非法时，程序也能适当地做出反应。
(2) 程序要添加适当的注释，程序的书写要采用缩进格式。
(3) 根据实验报告模板详细书写实验报告,源程序保存为“sy2.cpp”，实验报告命名为“实验报告2.doc”。
将这两个文件压缩为一个文件，按以下方式命名：学号姓名.rar，上传到ftp的相应班级所在文件夹。
二叉树的遍历算法实验报告
二叉树实验报告09信管石旭琳 20091004418一、实验目的：1、理解二叉树的遍历算法及应用2、理解哈夫曼树及其应用。
3、掌握哈夫曼编码思想。
二、实验内容：1、建立二叉树二叉链表2、实现二叉树递归遍历算法（中序、前序、后序）3、求二叉树高度4、求二叉树结点个数5、求二叉树叶子个数6、将序号为偶数的值赋给左子树三、主要程序：#include<stdio.h>#include<stdlib.h>typedef int ElemType;struct BiTNode{ElemType data;struct BiTNode *lch,*rch;}BiTNode,*BiTree;struct BiTNode *creat_bt1();struct BiTNode *creat_bt2();void preorder (struct BiTNode *t);void inorder (struct BiTNode *t);void postorder (struct BiTNode *t);void numbt (struct BiTNode *t);int n,n0,n1,n2;void main(){int k;printf("\n\n\n");printf("\n\n 1.建立二叉树方法1(借助一维数组建立)"); printf("\n\n 2.建立二叉树方法2(先序递归遍历建立)"); printf("\n\n 3.先序递归遍历二叉树");printf("\n\n 4.中序递归遍历二叉树");printf("\n\n 5.后序递归遍历二叉树");printf("\n\n 6.计算二叉树结点个数");printf("\n\n 7.结束程序运行");printf("\n==================================="); do{printf("\n请输入你要执行的操作(1,2,3,4,5,6,7)");scanf("%d",&k);printf("\n");switch(k){case 1:{printf("你选择的是操作1，现用方法1进行建立二叉树\n");BiTree=creat_bt1(); /* 调用性质5建立二叉树算法*/break;}case 2:{printf("你选择的是操作2，现用方法2进行建立二叉树\n");BiTree=creat_bt2(); /* 调用递归建立二叉树算法*/break;}case 3:{printf("你选择的是操作3，现进行先序递归遍历二叉树\n结果为:");preorder(BiTree);break;}case 4:{printf("你选择的是操作4，现进行中序递归遍历二叉树\n结果为:");inorder(BiTree);break;}case 5:{printf("你选择的是操作5，现进行后序递归遍历二叉树\n结果为:");postorder(BiTree);break;}case 6:{ n=0,n0=0,n1=0,n2=0; /*全局变量置0 */printf("你选择的是操作6，现进行计算二叉树结点个数\n结果为:");numbt(BiTree);printf("\n 二叉树结点总数是：%d",n);printf("\n 二叉树叶子结点数是：%d",n0);printf("\n 度为1的结点数是：%d",n1);printf("\n 度为2的结点数是：%d",n2);break;}case 7:{printf("你选择的是操作8，将结束本程序运行，谢谢你的使用，再见！\n");break;}}}while(k>=1&&k<7);}struct BiTNode *creat_bt1(){struct BiTNode *v[50],*p,*t;int i,j;ElemType e; /*输入结点的序号i、结点的数据e */printf("\n i,data=");scanf("%d,%d",&i,&e);while(i!=0&&e!=0){p=(struct BiTNode *)malloc(sizeof(struct BiTNode));p->data=e;p->lch=NULL;p->rch=NULL;v[i]=p;if (i==1) /*序号为1的结点是根*/t=p;else{j=(i+1)/2;if(i%2==0) /*序号为偶数，做左孩子*/v[j]->lch=p;elsev[j]->rch=p;}printf("\n i,data=");scanf("%d,%d",&i,&e);}return t;}struct BiTNode *creat_bt2(){struct BiTNode *t;int e;printf("\n data=");scanf("%d",&e);if(e==0) t=NULL; /*对于0值，不分配新结点*/else{t=(struct BiTNode *)malloc(sizeof(struct BiTNode));t->data=e;t->lch=creat_bt2(); /*左孩子获得新指针值*/t->rch=creat_bt2();}return (t);}void preorder (struct BiTNode *t){if(t){printf("%d ",t->data);preorder(t->lch);preorder(t->rch);}}void inorder (struct BiTNode *t){if(t){inorder(t->lch);printf("%d ",t->data);inorder(t->rch);}}void postorder(struct BiTNode *t){if(t){postorder(t->lch);postorder(t->rch);printf("%d ",t->data);}}void numbt(struct BiTNode *t){if(t){numbt(t->lch);{n++;if(t->lch==NULL&&t->rch==NULL)n0++;if((t->lch==NULL&&t->rch!=NULL)||(t->lch!=NULL&&t->rch==NUL L))n1++;if(t->lch!=NULL&&t->rch!=NULL)n2++;}numbt(t->rch);}}四、测试结果：五、小结：实操后还是会搞不清楚数据域及指针域的定义类型的不同。
计算机软件实验报告(2)二叉树的建立与遍历
二叉树的建立与遍历一、实验目的进一步理解二叉树的逻辑结构和存储结构，掌握二叉树的建立与遍历算法。
二、实验内容1、用二叉链表创建二叉树①输入根结点值；②若左子树不空，则输入左子树，否则输入一个结束符；③若右子树不空，则输入右子树，否则输入一个结束符。
例如：FCA▲▲DB▲▲▲E▲GH▲▲P▲▲其中▲表示结束符2、遍历该二叉树(1) 先序遍历(DLR)若二叉树为空，则结束返回。
否则：①访问根结点；②先序遍历左子树；③先序遍历右子树。
(2) 中序遍历(LDR)若二叉树为空，则结束返回。
否则：①中序遍历左子树；②访问根结点；③中序遍历左子树。
(3) 后序遍历(LRD)若二叉树为空，则结束返回。
否则：①后序遍历左子树；②后序遍历左子树；③访问根结点。
实验思想：根据要求，输入二叉树各结点对应的编号和数值，建立一棵空树，存储相应数值并使左子树和右子树均为空树，根据计算，若编号为偶数则为左子树，若为奇数则为右子树。
最后遍历二叉树。
三、实验算法流程图与程序清单（一）二叉树的建立与先序遍历：1、算法流程图：2、实验清单：{char data;struct node1 *lchild,*rchild;}BTCHINALR;BTCHINALR * createbt( ){ BTCHINALR *q;struct node1 *s[30];int j,i,x;printf("建立二叉树，输入结点对应的编号和值,编号和值之间用逗号隔开\n\n");printf("i,x = ");scanf("%d,%c",&i,&x);while(i != 0 && x != '$'){q = (BTCHINALR*)malloc(sizeof(BTCHINALR));q->data = x; q->lchild = NULL; q->rchild = NULL;s[i] = q;if(i != 1){j = i / 2;if(i % 2 == 0) s[j]->lchild = q;else s[j]->rchild = q;}printf("i,x = ");scanf("%d,%c",&i,&x);}return s[1];}void inorder(BTCHINALR *bt){if(bt != NULL){ inorder(bt->lchild);printf("%c ",bt->data);inorder(bt->rchild); }}main( ){ BTCHINALR *bt;char ch;int i;bt = createbt(); i = 1;while(i) {printf("\n先序遍历二叉树(递归按y键，): ");fflush(stdin);scanf("%c",&ch);if(ch == 'y') inorder(bt);printf("\n");}3、实验结果：建立二叉树，输入结点对应的编号和值,编号和值之间用逗号隔开i,x = 1,li,x = 2,ki,x = 3,yi,x = 4,bi,x =5,si,x = 7,ci,x =11,vi,x = 15,ri,x = 0,$先序遍历二叉树(递归按y键，): yl k b s v y c r（二）、二叉树的建立与中序遍历:1、算法流程图：2、实验清单：{char data;struct node1 *lchild,*rchild;}BTCHINALR;BTCHINALR * createbt( ){ BTCHINALR *q;struct node1 *s[30];int j,i,x;printf("建立二叉树，输入结点对应的编号和值,编号和值之间用逗号隔开\n\n");printf("i,x = ");scanf("%d,%c",&i,&x);while(i != 0 && x != '$'){q = (BTCHINALR*)malloc(sizeof(BTCHINALR));q->data = x; q->lchild = NULL; q->rchild = NULL;s[i] = q;if(i != 1){j = i / 2;if(i % 2 == 0) s[j]->lchild = q;else s[j]->rchild = q;}printf("i,x = ");scanf("%d,%c",&i,&x);}return s[1];}void inorder(BTCHINALR *bt){if(bt != NULL){ inorder(bt->lchild);printf("%c ",bt->data);inorder(bt->rchild); }}main( ){ BTCHINALR *bt;char ch;int i;bt = createbt(); i = 1;while(i) {printf("\n先序遍历二叉树(递归按y键，): ");fflush(stdin);scanf("%c",&ch);if(ch == 'y') inorder(bt);printf("\n");}3、实验结果：建立二叉树，输入结点对应的编号和值,编号和值之间用逗号隔开i,x = 1,li,x = 2,ki,x = 3,yi,x = 4,bi,x =5,si,x = 7,ci,x =11,vi,x = 15,ri,x = 0,$先序遍历二叉树(递归按y键，): yl k b s v y c r四、实验心得体会通过这次实验，锻炼了自己编程的能力，加深了自己对有关知识的理解。
二叉树的遍历实验报告
二叉树的遍历实验报告实验报告：二叉树的遍历（先序遍历、中序遍历、后序遍历）一、引言二叉树是一种非常常见的数据结构，在计算机领域有着广泛的应用。
对二叉树进行遍历操作是其中最基本的操作之一、本实验旨在通过对二叉树的先序遍历、中序遍历和后序遍历的实践，加深对二叉树遍历算法的理解和掌握。
二、目的1.掌握二叉树先序遍历的算法原理和实现方法；2.掌握二叉树中序遍历的算法原理和实现方法；3.掌握二叉树后序遍历的算法原理和实现方法；4.使用递归和非递归两种方式实现以上三种遍历算法；5.进行正确性验证和性能评估。
三、方法1.算法原理：1.1先序遍历：先访问根节点，然后递归遍历左子树，再递归遍历右子树；1.2中序遍历：先递归遍历左子树，然后访问根节点，最后递归遍历右子树；1.3后序遍历：先递归遍历左子树，再递归遍历右子树，最后访问根节点。
2.实现方法：2.1递归实现：采用函数递归调用的方式，实现对二叉树的遍历；2.2非递归实现：采用栈的数据结构，模拟递归的过程，实现对二叉树的遍历。
四、实验步骤1.数据结构设计：1.1定义二叉树的节点结构，包括节点值和两个指针（分别指向左子节点和右子节点）；1.2定义一个栈结构，用于非递归实现时的辅助存储。
2.先序遍历：2.1递归实现：按照先序遍历的原理，通过递归调用遍历左子树和右子树，再输出根节点；2.2非递归实现：通过栈结构模拟递归的过程，先将根节点入栈，然后循环将栈顶节点弹出并输出，再将其右子节点入栈，最后将左子节点入栈，直到栈为空。
3.中序遍历：3.1递归实现：按照中序遍历的原理，通过递归调用先遍历左子树，再输出根节点，最后遍历右子树；3.2非递归实现：先将根节点入栈，然后循环将左子节点入栈，直到左子节点为空，然后弹出栈顶节点并输出，再将其右子节点入栈，重复以上过程直到栈为空。
4.后序遍历：4.1递归实现：按照后序遍历的原理，通过递归调用先遍历左子树，再遍历右子树，最后输出根节点；4.2非递归实现：通过栈结构模拟递归的过程，先将根节点入栈，然后重复以下步骤直到栈为空。
二叉树的遍历实验报告
二叉树的遍历实验报告一、需求分析在二叉树的应用中，常常要求在树中查找具有某种特征的结点，或者对树中全部结点逐一进行某种处理，这就是二叉树的遍历问题。
对二叉树的数据结构进行定义，建立一棵二叉树，然后进行各种实验操作。
二叉树是一个非线性结构，遍历时要先明确遍历的规则，先访问根结点还时先访问子树，然后先访问左子树还是先访问有右子树，这些要事先定好，因为采用不同的遍历规则会产生不同的结果。
本次实验要实现先序、中序、后序三种遍历。
基于二叉树的递归定义，以及遍历规则，本次实验也采用的是先序遍历的规则进行建树的以及用递归的方式进行二叉树的遍历。
二、系统总框图三、各模块设计分析（1）建立二叉树结构建立二叉树时，要先明确是按哪一种遍历规则输入，该二叉树是按你所输入的遍历规则来建立的。
本实验用的是先序遍历的规则进行建树。
二叉树用链表存储来实现，因此要先定义一个二叉树链表存储结构。
因此要先定义一个结构体。
此结构体的每个结点都是由数据域data 、左指针域Lchild 、右指针域Rchild 组成，两个指针域分别指向该结点的左、右孩子，若某结点没有左孩子或者右孩子时，对应的指针域就为空。
最后，还需要一个链表的头指针指向根结点。
要注意的是，第一步的时候一定要先定义一个结束标志符号，例如空格键、＃等。
当它遇到该标志时，就指向为空。
建立左右子树时，仍然是调用create（）函数，依此递归进行下去，直到遇到结束标志时停止操作。
（2）输入二叉树元素输入二叉树时，是按上面所确定的遍历规则输入的。
最后，用一个返回值来表示所需要的结果。
（3）先序遍历二叉树当二叉树为非空时，执行以下三个操作：访问根结点、先序遍历左子树、先序遍历右子树。
（4）中序遍历二叉树当二叉树为非空时，程序执行以下三个操作：访问根结点、先序遍历左子树、先序遍历右子树。
（5）后序遍历二叉树当二叉树为非空时，程序执行以下三个操作：访问根结点、先序遍历左子树、先序遍历右子树。
二叉树二叉链表表示及实现实验报告
二叉树二叉链表表示及实现实验报告实验三二叉树的二叉链表表示及实现实验项目中文名称：二叉树的二叉链表表示及实现实验项目英文名称：Definition and Implementation of Binary Tree 实验学时：2学时一、实验目的1、深入了解二叉树的特性，掌握二叉树的二叉链表表示及实现方法。
2、掌握二叉树的递归遍历算法。
二、实验内容1、编写函数，创建一棵二叉树；2、编写函数，用递归算法分别求二叉树的各种遍历序列；3、编写函数，用非递归算法求二叉树的中序遍历序列。
4、编写函数，用非递归算法求二叉树的先序和后序遍历序列。
（选做）三、设计概要1、核心数据结构二叉树的链式存储结构表示typedef struct BiTNode{ElemType data;struct BiTNode *lchild, *rchild;} BiTNode;结构示意图：2,二叉树的链式存储算法实现Status CreateBiTree(BiTree * Tp){//创建一棵二叉树；char ch;scanf(“%c”,…ch);getchar();if(ch ==' ')Tp = NULL;else {Tp=(BiTree)malloc(sizeof(BiTNode));Tp->data=ch;printf(“输入%c的左子树：”,ch);creatBitree(Tp->lchild);printf(“输入%c的右子树：”,ch);creatBitree(Tp->rchild); }}程序框架结构与流程图遍历：即将树的所有结点访问且仅访问一次。
按照根节点位置的不同分为前序遍历，中序遍历，后序遍历。
前序遍历：根节点->左子树->右子树中序遍历：左子树->根节点->右子树后序遍历：左子树->右子树->根节点（1）序遍历二叉树：若二叉树为空，则空操作；否则，先访问根节点->先序遍历左子树->先序遍历右子树。
二叉树遍历 实验报告
数据结构实验报告报告题目: 二叉树的基本操作学生班级:学生姓名: 学号:一. 实验目的1、基本要求: 深刻理解二叉树性质和各种存储结构的特点及适用范围；掌握用指针类型描述、访问和处理二叉树的运算；熟练掌握二叉树的遍历算法；。
2. 较高要求: 在遍历算法的基础上设计二叉树更复杂操作算法；认识哈夫曼树、哈夫曼编码的作用和意义;掌握树与森林的存储与便利。
二.实验学时：课内实验学时: 3学时课外实验学时: 6学时三. 实验题目1. 以二叉链表为存储结构, 实现二叉树的创建、遍历（实验类型: 验证型）1）问题描述：在主程序中设计一个简单的菜单, 分别调用相应的函数功能：1…建立树2…前序遍历树3…中序遍历树4…后序遍历树5…求二叉树的高度6…求二叉树的叶子节点7…非递归中序遍历树0…结束2）实验要求: 在程序中定义下述函数, 并实现要求的函数功能:CreateBinTree(BinTree &T): 按从键盘输入的前序序列, 创建树Preorder(BinTree &T): 前序遍历树（递归）Inorder(BinTree &T): 中序(递归)遍历树Postorder(BinTree &T): 后序遍历树（递归）PostTreeDepth(BinTree &T): 树的高度leaf(BinTree &T):树的叶子节点InorderN(BinTree &T): 中序(非递归)遍历树3)数据结构二叉链表存储数据类型定义typedef struct node{TElemType data;struct node *lchild,*rchild;}BinTNode;元素类型:int CreateBinTree(BinTree &T);void Preorder(BinTree &T);void Inorder(BinTree &T);void Postorder(BinTree &T);void InorderN(BinTree &T);int PostTreeDepth(BinTree &T);int leaf(BinTree &T);2.编写算法实现二叉树的非递归中序遍历和求二叉树高度。
二叉树遍历实验报告
二叉树遍历实验报告二叉树遍历实验报告一、引言二叉树是计算机科学中常用的数据结构之一，它由节点组成，每个节点最多有两个子节点。
二叉树的遍历是指按照一定的规则访问二叉树中的所有节点。
本实验旨在通过实际操作，探索二叉树的三种遍历方式：前序遍历、中序遍历和后序遍历，并分析它们的应用场景和性能特点。
二、实验方法1. 实验环境本实验使用Python编程语言进行实现，并在Jupyter Notebook中运行代码。
2. 实验步骤（1）定义二叉树节点类首先，我们定义一个二叉树节点类，该类包含节点值、左子节点和右子节点三个属性。
（2）构建二叉树在主函数中，我们手动构建一个二叉树，包含多个节点，并将其保存为根节点。
（3）实现三种遍历方式通过递归的方式，实现二叉树的前序遍历、中序遍历和后序遍历。
具体实现过程如下：- 前序遍历：先访问根节点，然后递归遍历左子树，最后递归遍历右子树。
- 中序遍历：先递归遍历左子树，然后访问根节点，最后递归遍历右子树。
- 后序遍历：先递归遍历左子树，然后递归遍历右子树，最后访问根节点。
（4）测试遍历结果在主函数中，我们调用实现的三种遍历方式，对构建的二叉树进行遍历，并输出结果。
三、实验结果与分析经过实验，我们得到了二叉树的前序遍历、中序遍历和后序遍历的结果。
以下是我们的实验结果及分析：1. 前序遍历结果前序遍历结果为：A - B - D - E - C - F - G前序遍历的应用场景包括：复制整个二叉树、计算二叉树的深度和宽度等。
前序遍历的时间复杂度为O(n)，其中n为二叉树的节点数。
2. 中序遍历结果中序遍历结果为：D - B - E - A - F - C - G中序遍历的应用场景包括：二叉搜索树的中序遍历可以得到有序的节点序列。
中序遍历的时间复杂度为O(n)，其中n为二叉树的节点数。
3. 后序遍历结果后序遍历结果为：D - E - B - F - G - C - A后序遍历的应用场景包括：计算二叉树的高度、判断二叉树是否对称等。
数据结构实验报告-二叉树的实现与遍历
《数据结构》第六次实验报告学生姓名学生班级学生学号指导老师一、实验内容1) 采用二叉树链表作为存储结构，完成二叉树的建立，先序、中序和后序以及按层次遍历的操作，求所有叶子及结点总数的操作。
2) 输出树的深度，最大元，最小元。
二、需求分析遍历二叉树首先有三种方法，即先序遍历，中序遍历和后序遍历。
递归方法比较简单，首先获得结点指针如果指针不为空，且有左子，从左子递归到下一层，如果没有左子，从右子递归到下一层，如果指针为空，则结束一层递归调用。
直到递归全部结束。
下面重点来讲述非递归方法：首先介绍先序遍历：先序遍历的顺序是根左右，也就是说先访问根结点然后访问其左子再然后访问其右子。
具体算法实现如下：如果结点的指针不为空，结点指针入栈，输出相应结点的数据，同时指针指向其左子，如果结点的指针为空，表示左子树访问结束，栈顶结点指针出栈，指针指向其右子，对其右子树进行访问，如此循环，直至结点指针和栈均为空时，遍历结束。
再次介绍中序遍历：中序遍历的顺序是左根右，中序遍历和先序遍历思想差不多，只是打印顺序稍有变化。
具体实现算法如下：如果结点指针不为空，结点入栈，指针指向其左子，如果指针为空，表示左子树访问完成，则栈顶结点指针出栈，并输出相应结点的数据，同时指针指向其右子，对其右子树进行访问。
如此循环直至结点指针和栈均为空，遍历结束。
最后介绍后序遍历：后序遍历的顺序是左右根，后序遍历是比较难的一种，首先需要建立两个栈，一个用来存放结点的指针，另一个存放标志位，也是首先访问根结点，如果结点的指针不为空，根结点入栈，与之对应的标志位也随之入标志位栈，并赋值0，表示该结点的右子还没有访问，指针指向该结点的左子，如果结点指针为空，表示左子访问完成，父结点出栈，与之对应的标志位也随之出栈，如果相应的标志位值为0，表示右子树还没有访问，指针指向其右子，父结点再次入栈，与之对应的标志位也入栈，但要给标志位赋值为1，表示右子访问过。
二叉树地创建与遍历实验报告
数据结构课内实验报告书一、实验题目：二叉树的创建与遍历二、实验目的：通过本次实验，熟练掌握二叉树的存储结构定义及其遍历算法的实现，学会利用栈编写非递归的遍历算法。
三、实验要求：建立一棵用二叉链表方式存储的二叉树，并对其进行遍历（先序、中序和后序），打印输出遍历结果。
要求：从键盘接受扩展先序序列，以二叉链表作为存储结构，建立二叉树，并将遍历结果打印输出。
采用递归和非递归两种方法实现。
四、设计与实现过程（1）存储结构定义typedefcharelemtype;typedefstructNode{elemtypedata;structNode*lchild;structNode*rchild;}BitNode;（2）算法描述Node*creat(Node*pre){chare;Node*head;e=getchar();if(e!=''){head=(Node*)malloc(sizeof(Node));head->data=e;head->Lchild=creat(head);if(head->Lchild==NULL){head->Lflag=1;head->Lchild=pre;}head->Rchild=creat(head);if(pre!=NULL&&pre->Rchild==NULL){ pre->Rflag=1;pre->Rchild=head;}returnhead;}else{returnNULL;}}Node*InPre(Node*root){Node*p;if(root->Lflag==1){p=root->Lchild;}else{for(p=root->Lchild;p->Rflag==0;p=p->Rchild); }returnp;}Node*InNext(Node*root){Node*p;if(root->Rflag==1){p=root->Rchild;}else{for(p=root->Rchild;p->Lflag==0;p=p->Lchild);}returnp;}Node*Infirst(Node*root){Node*p;p=root;if(!p){fprintf(stdout,"n");returnNULL;}while(p->Lflag==0){p=p->Lchild;}returnp;}voidTInOrder(Node*root){Node*p;p=Infirst(root);while(p!=NULL){fprintf(stdout,"%c",p->data);p=InNext(p);}printf("\n");}五、运行结果输入ABECD输出BEADC六、技巧与体会通过实验，锻炼了自己的能力，加深了自己对有关知识的理解。
二叉树实验报告
二叉树实验报告1 实验目的1、熟悉二叉树的二叉链表存储结构；2、掌握构造二叉树的方法；3、加深对二叉树前序、中序、后序遍历的理解。
2 需求分析2.1 任务1二叉树的二叉链表存储结构及实现，将参考程序中的三段函数代码补齐。
约束条件：沿用源代码中链表结构体。
输入要求：输入一个二叉树链表。
输出要求：若是二叉树链表不为空则对二叉树链表进行先序遍历。
2.2 任务2功能：int HeightBTree(BTNode *bt) 求二叉树的深度。
约束条件：沿用源代码中链表结构体。
输入要求：输入一个二叉树链表。
输出要求：若是二叉树链表为空则返回0，若二叉树链表不为空则统计出该二叉树的深度，然后返回该值。
2.3 任务3功能：void DisplayBTree(BTNode * bt，int i) 输出二叉树第i层的所有节点。
约束条件：沿用源代码中链表结构体。
输入要求：输入一个二叉树链表。
输出要求：若输入的i小于1，或者二叉树链表为空则直接返回，若二叉树链表不为空且i值符合要求，则打印i层所有的节点。
3概要设计3.1任务1void PreOrder(BTNode *bt)该函数首先，你需要定义一个二叉树节点的数据结构，通常包含一个值和两个指向左右子节点的指针。
在先序遍历函数中，首先访问根节点，然后递归地遍历左子树，最后递归地遍历右子树。
并在控制台上输出每个节点的值。
void InOrder(BTNode *bt) 该函数首先判断当前节点是否为空，如果为空则返回。
递归遍历左子树。
访问当前节点，输出节点的值。
递归遍历右子树。
通过这样的递归过程，我们可以实现对整个二叉树的中序遍历。
void PostOrder(BTNode *bt)该函数首先判断当前节点是否为空，如果为空则返回。
递归遍历左子树。
递归遍历右子树。
访问当前节点，输出节点的值。
通过这样的递归过程，我们可以实现对整个二叉树的后序遍历。
3.2任务2int HeightBTree(BTNode *bt)该函数首先判断当前节点是否为空，如果为空则返回0。
二叉树的遍历实验报告(二)
二叉树的遍历实验报告（二）引言：本实验报告是对二叉树的遍历进行实验，并对实验结果进行分析和总结。
二叉树的遍历是指按照某种顺序遍历二叉树中的节点，分为三种遍历方式：前序遍历、中序遍历和后序遍历。
本实验通过设计并实现相应的算法，对三种遍历方式进行实验，并比较它们在不同情况下的效率和应用场景。
一、前序遍历1. 创建一个空栈，将二叉树的根节点压入栈中。
2. 当栈不为空时，执行以下操作：2.1 弹出栈顶节点，输出节点值。
2.2 若节点存在右子树，将右子树的根节点压入栈中。
2.3 若节点存在左子树，将左子树的根节点压入栈中。
3. 重复步骤2，直到栈为空。
二、中序遍历1. 创建一个空栈，并将二叉树的根节点置为当前节点。
2. 当栈不为空或当前节点不为空时，执行以下操作：2.1 若当前节点不为空，将当前节点入栈，并将当前节点指向其左子节点。
2.2 若当前节点为空，弹出栈顶节点并输出节点值，将当前节点指向其右子节点。
3. 重复步骤2，直到栈为空且当前节点为空。
三、后序遍历1. 创建两个栈，分别为stack1和stack2。
将二叉树的根节点压入stack1中。
2. 当stack1不为空时，执行以下操作：2.1 弹出stack1的栈顶节点，并将该节点压入stack2中。
2.2 若节点存在左子树，将左子树的根节点压入stack1中。
2.3 若节点存在右子树，将右子树的根节点压入stack1中。
3. 当stack1为空时，执行以下操作：3.1 弹出stack2的栈顶节点并输出节点值。
4. 重复步骤2和3，直到stack1和stack2均为空。
四、效率比较1. 前序遍历的时间复杂度为O(n)，其中n为二叉树的节点数量。
2. 中序遍历的时间复杂度为O(n)。
3. 后序遍历的时间复杂度为O(n)。
4. 从时间复杂度上看，三种遍历方式的效率相同。
5. 从实际使用场景上看，前序遍历适合用于打印二叉树的结构、以及复制整棵树等；中序遍历适合用于查找二叉搜索树中的某个值；后序遍历适合用于计算二叉树中节点的高度或深度等。
二叉树的建立和遍历实验报告
二叉树的建立和遍历实验报告一、引言（100字）二叉树是一种常见的数据结构，它由根节点、左子树和右子树组成，具有递归性质。
本次实验的目的是了解二叉树的建立过程和遍历算法，以及熟悉二叉树的相关操作。
本实验采用C语言进行编写。
二、实验内容（200字）1.二叉树的建立：通过输入节点的值，逐个建立二叉树的节点，并通过指针连接起来。
2.二叉树的遍历：实现二叉树的三种常用遍历算法，即前序遍历、中序遍历和后序遍历。
三、实验过程（400字）1.二叉树的建立：首先，定义二叉树的节点结构，包含节点值和指向左右子树的指针；然后，通过递归的方式，依次输入节点的值，创建二叉树节点，建立好节点之间的连接。
2.二叉树的前序遍历：定义一个函数，实现前序遍历的递归算法，先输出当前节点的值，再递归遍历左子树和右子树。
3.二叉树的中序遍历：同样，定义一个函数，实现中序遍历的递归算法，先递归遍历左子树，再输出当前节点的值，最后递归遍历右子树。
4.二叉树的后序遍历：同样，定义一个函数，实现后序遍历的递归算法，先递归遍历左子树和右子树，再输出当前节点的值。
四、实验结果（300字）通过实验，我成功建立了一个二叉树，并实现了三种遍历算法。
对于建立二叉树来说，只要按照递归的思路，先输入根节点的值，再分别输入左子树和右子树的值，即可依次建立好节点之间的连接。
建立好二叉树后，即可进行遍历操作。
在进行遍历算法的实现时，我首先定义了一个函数来进行递归遍历操作。
在每一次递归调用中，我首先判断当前节点是否为空，若为空则直接返回；若不为空，则按照特定的顺序进行遍历操作。
在前序遍历中，我先输出当前节点的值，再递归遍历左子树和右子树；在中序遍历中，我先递归遍历左子树，再输出当前节点的值，最后递归遍历右子树；在后序遍历中，我先递归遍历左子树和右子树，再输出当前节点的值。
通过运行程序，我成功进行了二叉树的建立和遍历，并得到了正确的结果。
可以看到，通过不同的遍历顺序，可以获得不同的遍历结果，这也是二叉树遍历算法的特性所在。
数据结构实验二 树的二叉链表表示及其遍历
《数据结构与算法》
（2012-2013 学年第 2 学期）
实 验 报 告
学号： 姓名： 班级：
对全部高中资料试卷电气设备，在安装过程中以及安装结束后进行高中资料试卷调整试验；通电检查所有设备高中资料电试力卷保相护互装作置用调与试相技互术关，系电，力根通保据过护生管高产线中工敷资艺设料高技试中术卷资，配料不置试仅技卷可术要以是求解指，决机对吊组电顶在气层进设配行备置继进不电行规保空范护载高与中带资负料荷试下卷高问总中题体资，配料而置试且时卷可，调保需控障要试各在验类最；管大对路限设习度备题内进到来行位确调。保整在机使管组其路高在敷中正设资常过料工程试况中卷下，安与要全过加，度强并工看且作护尽下关可都于能可管地以路缩正高小常中故工资障作料高；试中对卷资于连料继接试电管卷保口破护处坏进理范行高围整中，核资或对料者定试对值卷某，弯些审扁异核度常与固高校定中对盒资图位料纸置试，.卷保编工护写况层复进防杂行腐设自跨备动接与处地装理线置，弯高尤曲中其半资要径料避标试免高卷错等调误，试高要方中求案资技，料术编试交写5、卷底重电保。要气护管设设装线备备置敷4高、调动设中电试作技资气高，术料课中并3中试、件资且包卷管中料拒含试路调试绝线验敷试卷动槽方设技作、案技术，管以术来架及避等系免多统不项启必方动要式方高，案中为；资解对料决整试高套卷中启突语动然文过停电程机气中。课高因件中此中资，管料电壁试力薄卷高、电中接气资口设料不备试严进卷等行保问调护题试装，工置合作调理并试利且技用进术管行，线过要敷关求设运电技行力术高保。中护线资装缆料置敷试做设卷到原技准则术确：指灵在导活分。。线对对盒于于处调差，试动当过保不程护同中装电高置压中高回资中路料资交试料叉卷试时技卷，术调应问试采题技用，术金作是属为指隔调发板试电进人机行员一隔，变开需压处要器理在组；事在同前发一掌生线握内槽图部内 纸故，资障强料时电、，回设需路备要须制进同造行时厂外切家部断出电习具源题高高电中中源资资，料料线试试缆卷卷敷试切设验除完报从毕告而，与采要相用进关高行技中检术资查资料和料试检，卷测并主处且要理了保。解护现装场置设。备高中资料试卷布置情况与有关高中资料试卷电气系统接线等情况，然后根据规范与规程规定，制定设备调试高中资料试卷方案。
实验2 树的二叉链表表示及其遍历
intCreateBiTree(BiTree *T)
{
ElemType all[16]={0,1,2,3,0,0,4,5,0,0,0,0,6,0,0,0,};
CreateSubTree(T,all,1);
}
voidprintelem(ElemType d)
{
printf("%d\n",d);
}
intPreOrderTraverse(BiTree T,int (*Visit)(ElemType d))
PreOrderTraverse(T->r);
}
}
void PostOrderTraverse(BiTree T)
{
if(T)
{
PreOrderTraverse(T->l);
PreOrderTraverse(T->r);
printf("%d ",T->data);
}
}
int main()
{
BiTree root;
}
int CreateBiTree(BiTree *T)
{
ElemType all[16]={0,1,2,3,0,0,4,5,0,0,0,0,6,0,0,0};
CreateSubTree(T,all,1);
}
int printelem(ElemType d)
{
printf(" %d\n",d);
}
void InOrderTraverse(BiTree T)
{
if ((all[i]==0)||i>16)
{
*T=NULL;
return OK;
用二叉链表实现二叉树的基本操作
用二叉链表实现二叉树的基本操作(构造及遍历等)c++ 2008-10-05 13:47:25|分类：C++ | 标签：|字号大中小订阅/*先序遍历二叉树若二叉树为空，则空操作；否则(1) 访问根结点；(2) 先序遍历左子树；(3) 先序遍历右子树。
若二叉树为空，则空操作；中序遍历二叉树若二叉树为空，则空操作；否则(1) 中序遍历左子树；(2) 访问根结点；(3) 中序遍历右子树。
若二叉树为空，则空操作；后序遍历二叉树若二叉树为空，则空操作；否则(1) 后序遍历左子树；(2) 后序遍历右子树；(3) 访问根结点。
*/#include <iostream>using std::ci n;using std::c out;using std::endl;typedef s truct BiTNode {char data;struct BiTNode *Lc hild, *Rc hild; // 左、右孩子指针} *BiTree;v oi d CreateBiTree(BiTree &T){// 在先序遍历二叉树的过程中输入二叉树的"先序字符串"，// 建立根指针为T的二叉链表存储结构。
在先序字符串中，// 字符'#'表示空树，其它字母字符为结点的数据元素char ch;cin >> ch ;if (ch=='#'){T=NULL; // 建空树}else {T = new BiTNode ; // "访问"操作为生成根结点T->data = c h;CreateBiTree(T->Lchild); // 递归建(遍历)左子树CreateBiTree(T->Rchild); // 递归建(遍历)右子树}//else}//CreateBiTree//先序遍历以T为根指针的二叉树v oi d PreOrder(BiTree &T){if(T){ // T=NULL时，二叉树为空树，不做任何操作c out<< T->data << " "; // 通过函数指针*v isit 访问根结点PreOrder(T->Lchild); // 先序遍历左子树PreOrder(T->Rchild); // 先序遍历右子树}// if}//中序遍历以T为根指针的二叉树v oi d InOrder(BiTree &T){if(T){ // T=NULL时，二叉树为空树，不做任何操作InOrder(T->Lchild); // 先序遍历左子树c out<< T->data << " "; // 通过函数指针*v isit 访问根结点InOrder(T->Rchild); // 先序遍历右子树}// if}//后序遍历以T为根指针的二叉树v oi d PostOrder(BiTree &T){if(T){ // T=NULL时，二叉树为空树，不做任何操作PostOrder(T->Lchild); // 先序遍历左子树PostOrder(T->Rchild); // 先序遍历右子树c out<< T->data << " "; // 通过函数指针*v isit 访问根结点}// if}// 先序遍历二叉树，以count 返回二叉树中叶子结点的数目v oi d CountLeaf(BiTree &T, int &count){if (T) {if ((!T->Lchild)&& (!T->Rchild))count++; // 对叶子结点计数C ountLeaf( T->Lchild, count);C ountLeaf( T->Rchild, c ount);} // if} // CountLeaf// T指向二叉树的根，lev el 为T 所指结点所在层次，// 其初值为1，depth 为当前求得的最大层次,其初值为0 v oi d BiTreeD epth(BiTree T, int l ev el, int &depth){if (T){if (level>depth) depth=level;BiTreeDepth(T->Lchild, lev el+1, depth);BiTreeDepth(T->Rchild, level+1, depth);}// if}// BiTreeDepthint main(){cout << "请依次输入字符: AB#CD###E#F##" << endl;BiTree T;CreateBiTree(T);cout << "先序遍历: " << endl;PreOrder(T);cout << endl << "中序遍历: " << endl;InOrder(T);cout << endl << "后序遍历: " << endl;Pos tOrder(T);int c ount = 0;CountLeaf (T,count);cout << endl << "此二叉树叶子节点个数: " << count << endl;int depth = 0;BiTreeDepth(T,1,depth);cout << endl << "此二叉树深度: " << depth << endl;retur n (0);}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
printf("先序遍历结果：");
PreOrderTraverse(root);
printf("\n");
printf("中序遍历结果：");
InOrderTraverse(root);
printf("\n");
printf("后序遍历结果：");
PostOrderTraverse(root);
PreOrderTraverse(T->r);
}
}
void PostOrderTraverse(BiTree T)
{
if(T)
{
PreOrderTraverse(T->l);
PreOrderTraverse(T->r);
printf("%d ",T->data);
}
}
int main()
{
BiTree root;
InOrderTraverse(T,Visit());
PostOrderTraverse(T,Visit());
示例源程序
#include <alloc.h>
#define ERROR 0;
#define OK 1;
typedef int ElemType;
typedef struct BinaryTree
struct BitNode *lchild,*rchild;
}BiTNode,*BiTree;
2,二叉树的链式存储算法实现
CreateBiTree(&T,definition);
InsertChild(T,p,LR,c);
3,二叉树的递归法遍历
PreOrderTraverse(T,Visit());
{
if(T){
if(Visit(T->data))
if(PreOrderTraverse(T->l,Visit))
if(PreOrderTraverse(T->r,Visit)) return OK;
return ERROR;
}
else
return OK;
}
intmain()
{
BiTree root;
{
ElemType data;
struct BinaryTree *l;
struct BinaryTree *r;
}*BiTree,BiNode;
BiNode * new()
{
return( (BiNode *)malloc(sizeof(BiNode)) );
}
intCreateSubTree(BiTree *T,ElemType *all,int i)
{
ElemType data;
struct BinaryTree *l;
struct BinaryTree *r;
}*BiTree,BiNode;
int CreateSubTree(BiTree *T,ElemType *all,int i)
{
*T=(BiTree)malloc(sizeof(BiTree));
{
if(T)
{
InOrderTraverse(T->l);
printf("%d ",T->data);
InOrderTraverse(T->r);
}
}
void PreOrderTraverse(BiTree T)
{
if(T)
{பைடு நூலகம்
printf("%d ",T->data);
PreOrderTraverse(T->l);
{
if ((all[i]==0)||i>16)
{
*T=NULL;
return OK;
}
*T=new();
if(*T==NULL) return ERROR;
(*T)->data=all[i];
CreateSubTree(&((*T)->l),all,2*i);
CreateSubTree(&((*T)->r),all,2*i+1);
printf("\n");
return 0;
}
}
intCreateBiTree(BiTree *T)
{
ElemType all[16]={0,1,2,3,0,0,4,5,0,0,0,0,6,0,0,0,};
CreateSubTree(T,all,1);
}
voidprintelem(ElemType d)
{
printf("%d\n",d);
}
intPreOrderTraverse(BiTree T,int (*Visit)(ElemType d))
if((all[i]==0)||i>16)
{
*T=NULL;
return 1;
}
if(*T==NULL) return 0;
(*T)->data=all[i];
CreateSubTree(&((*T)->l),all,2*i);
CreateSubTree(&((*T)->r),all,2*i+1);
}
int CreateBiTree(BiTree *T)
{
ElemType all[16]={0,1,2,3,0,0,4,5,0,0,0,0,6,0,0,0};
CreateSubTree(T,all,1);
}
int printelem(ElemType d)
{
printf(" %d\n",d);
}
void InOrderTraverse(BiTree T)
实验2树的二叉链表表示及其遍历
实验目的：掌握二叉树的链式存储结构及其遍历
实验重点：二叉树的链式存储实现方法
实验内容：用二叉链表存储结构表示下图所示二叉树的，并用递归方法输出三种遍历结果。
实验提示:
1,二叉树的链式存储结构表示
typedef struct BiTNode{
TElemType data;
CreateBiTree(&root);
PreOrderTraverse(root,printelem);
}
代码如下
#include<stdio.h>
#include <alloc.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct BinaryTree