实验三 二叉树基本运算以及遍历
二叉树的遍历实验报告

二叉树的遍历实验报告二叉树的遍历实验报告引言:二叉树是一种常见的数据结构,它由节点和连接节点的边组成。
在实际应用中,我们经常需要对二叉树进行遍历,以便对其中的节点进行访问和操作。
本次实验旨在探索二叉树的遍历算法,并通过实验验证其正确性和效率。
一、二叉树的定义和基本操作二叉树是一种特殊的树结构,每个节点最多有两个子节点,分别称为左子节点和右子节点。
根据节点的访问顺序,二叉树的遍历可以分为前序遍历、中序遍历和后序遍历三种方式。
前序遍历是指先访问根节点,然后按照左子树、右子树的顺序递归地进行遍历;中序遍历是指先按照左子树、根节点、右子树的顺序递归地进行遍历;后序遍历是指先按照左子树、右子树、根节点的顺序递归地进行遍历。
二、实验设计和方法为了验证二叉树的遍历算法的正确性和效率,我们设计了以下实验方案:1. 构建二叉树:我们首先构建一个具有一定规模的二叉树,以模拟实际应用中的情况。
为了方便起见,我们选择随机生成一棵二叉树,并确保其结构合理。
2. 实现遍历算法:我们根据前文所述的遍历方式,实现了相应的遍历算法。
在实现过程中,我们考虑到了递归和迭代两种方式,并分别进行了实验比较。
3. 遍历实验:我们使用不同规模的二叉树进行遍历实验,并记录遍历的结果和所花费的时间。
通过对比不同规模下不同遍历方式的结果和时间,我们可以评估遍历算法的效率和准确性。
三、实验结果和分析在实验中,我们构建了一棵具有1000个节点的二叉树,并分别使用前序、中序和后序遍历算法进行遍历。
通过实验结果的比较,我们得出以下结论:1. 遍历结果的正确性:无论是前序、中序还是后序遍历,我们都能够正确地访问到二叉树中的每个节点。
这表明我们所实现的遍历算法是正确的。
2. 遍历算法的效率:在1000个节点的二叉树中,我们发现中序遍历算法的执行时间最短,后序遍历算法的执行时间最长,前序遍历算法的执行时间居中。
这是因为中序遍历算法在访问节点时可以尽可能地减少递归次数,而后序遍历算法需要递归到最深层才能返回。
实验三--二叉树的基本运算

实验三二叉树的基本运算一、实验目的1、使学生熟练掌握二叉树的逻辑结构和存储结构。
2、熟练掌握二叉树的各种遍历算法。
二、实验内容1、问题描述建立一棵二叉树,试编程实现二叉树的如下基本操作:(1). 按先序序列构造一棵二叉链表表示的二叉树T;(2). 对这棵二叉树进行遍历:先序、中序、后序以及层次遍历,分别输出结点的遍历序列;(3). 求二叉树的深度/结点数目/叶结点数目;(选做)(4). 将二叉树每个结点的左右子树交换位置。
(选做)2、基本要求从键盘接受输入(先序),以二叉链表作为存储结构,建立二叉树(以先序来建立)。
3、测试数据如输入:abc00de0g00f000(其中ф表示空格字符)则输出结果为:先序:a->b->c->d->e->g->f中序:a->b->c->d->e->g->f后序:a->b->c->d->e->g->f三、程序代码#include<malloc.h>#include<iostream.h>#define OK 1#define ERROR -1typedef char TElemType;int i;typedef struct BiTNode{TElemType data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;int CreateBiTree(BiTree&T) //创建二叉树{char a;cin>>a;if(a=='0') T=NULL;else{if(!(T=(BiTNode*)malloc(sizeof(BiTNode)))) {return ERROR;}T->data=a;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}return OK;}int PreOrderTraverse(BiTree&T) //先序遍历二叉树{if(T){//cout<<"此为先序遍历"<<endl;cout<<T->data<<"->";if(PreOrderTraverse(T->lchild))if(PreOrderTraverse(T->rchild))return OK;return ERROR;}else return OK;}int InOrderTraverse(BiTree&T) //中序遍历二叉树{if(T){//cout<<"此为中序遍历"<<endl;if(InOrderTraverse(T->lchild)){cout<<T->data<<"->";if(InOrderTraverse(T->rchild))return OK;}return ERROR;}else return OK;}int PostOrderTraverse(BiTree&T) //后序遍历二叉树{if(T){//cout<<"此为后序遍历"<<endl;if (PostOrderTraverse(T->lchild))if(PostOrderTraverse(T->rchild)){cout<<T->data<<"->";i++;return (OK);}return (ERROR);}elsereturn (OK);}int CountDepth(BiTree&T) //计算二叉树的深度{if(T==NULL){return 0;}else{int depl=CountDepth(T->lchild);int depr=CountDepth(T->lchild);if(depl>depr){return depl+1;}else{return depr+1;}}}void main() //主函数{BiTree T;cout<<"请输入二叉树节点的值以创建树"<<endl;CreateBiTree(T);cout<<"此为先序遍历";PreOrderTraverse(T);cout<<"end"<<endl;cout<<"此为中序遍历";InOrderTraverse(T);cout<<"end"<<endl;cout<<"此为后序遍历";PostOrderTraverse(T);cout<<"end"<<endl<<"此树节点数是"<<i<<endl<<"此树深度是"<<CountDepth(T)<<endl;}四、调试结果及运行界面:五、实验心得通过这次程序上机实验让我认识到了以前还不太了解的二叉树的性质和作用,这次实验的的确确的加深了我对它的理解。
二叉树的构造遍历及运算

二叉树的构造遍历及运算二叉树是一种树状数据结构,其中每个节点最多有两个子节点,分别称为左子节点和右子节点。
构造、遍历和运算是二叉树操作的重要方面。
1. 二叉树的构造:二叉树可以通过递归或迭代的方式进行构造。
一个二叉树节点通常包含一个值和两个指向左右子树的指针。
```pythonclass TreeNode:def __init__(self, value):self.value = valueself.left = Noneself.right = None# 例子:手动构造一个简单的二叉树root = TreeNode(1)root.left = TreeNode(2)root.right = TreeNode(3)root.left.left = TreeNode(4)root.left.right = TreeNode(5)```2. 二叉树的遍历:二叉树的三种常见遍历方式分别是前序遍历(Preorder)、中序遍历(Inorder)和后序遍历(Postorder):# 前序遍历(Preorder):```pythondef preorder_traversal(node):if node:print(node.value, end=" ")preorder_traversal(node.left)preorder_traversal(node.right)# 测试前序遍历preorder_traversal(root)```# 中序遍历(Inorder):```pythondef inorder_traversal(node):if node:inorder_traversal(node.left)print(node.value, end=" ")inorder_traversal(node.right)# 测试中序遍历inorder_traversal(root)```# 后序遍历(Postorder):```pythondef postorder_traversal(node):if node:postorder_traversal(node.left)postorder_traversal(node.right)print(node.value, end=" ")# 测试后序遍历postorder_traversal(root)```3. 二叉树的运算:二叉树常用于实现各种算法和数据结构。
二叉树的遍历(先序遍历、中序遍历、后序遍历全)实验报告

实验目的编写一个程序,实现二叉树的先序遍历,中序遍历,后序遍历。
实验内容编程序并上机调试运行。
编写一个程序,实现二叉树的先序遍历,中序遍历,后序遍历。
编写程序/***********二叉树的遍历**************/#include<stdio.h>#include<stdlib.h>typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;/*************************************************///按先序次序构建的二叉树链表void CreatBiTree(BiTree *T){char ch;if((ch=getchar())==' ')*T=NULL;else{*T=(BiTNode*)malloc(sizeof(BiTNode));if(!(*T))exit(1);(*T)->data=ch;CreatBiTree(&(*T)->lchild);CreatBiTree(&(*T)->rchild);}}/*************************************************/ //先序遍历--递归算法void PreOrderTraverse(BiTree T){if(T){printf("%c",T->data);PreOrderTraverse(T->lchild);PreOrderTraverse(T->rchild);}}/*************************************************/ //中序遍历--递归算法void InOrderTraverse(BiTree T){if(T){InOrderTraverse(T->lchild);printf("%c",T->data);InOrderTraverse(T->rchild);}}/*************************************************/ //后序遍历--递归算法void PostOrderTraverse(BiTree T){if(T){PostOrderTraverse(T->lchild);PostOrderTraverse(T->rchild);printf("%c",T->data);}}/*************************************************/ //main函数void main(){BiTree T;printf("请按先序次序输入二叉树中结点的值,空格字符表示空树:\n" );CreatBiTree(&T);printf("\n");printf("先序遍历为:\n");PreOrderTraverse(T);printf("\n\n");printf("中序遍历为:\n");InOrderTraverse(T);printf("\n\n");printf("后序遍历为:\n");PostOrderTraverse(T);printf("\n\n");getchar();}运行程序:结果分析:按先序输入的二叉树为ABC^^DE^G^^F^^^(^为空格)该二叉树画成树形为:其先序遍历为:ABCDEGF其中序遍历为:CBEGDFA其后序遍历为:CGEFDBA可以看出运行结果是正确的。
二叉树的操作实验报告

二叉树的操作实验报告二叉树的操作实验报告引言二叉树是计算机科学中常用的数据结构,它具有良好的搜索性能和灵活的插入和删除操作。
本实验旨在通过实际操作,深入理解二叉树的基本操作和特性。
1. 二叉树的定义和基本概念二叉树是一种特殊的树状结构,每个节点最多有两个子节点,分别称为左子节点和右子节点。
二叉树的节点由数据和指向左右子节点的指针组成。
根据节点的位置,可以将二叉树分为左子树、右子树和根节点。
2. 二叉树的遍历二叉树的遍历是指按照一定的顺序访问二叉树中的所有节点。
常用的遍历方式有前序遍历、中序遍历和后序遍历。
前序遍历先访问根节点,然后按照左子树、右子树的顺序遍历;中序遍历先访问左子树,然后根节点,最后右子树;后序遍历先访问左子树,然后右子树,最后根节点。
3. 二叉树的插入操作插入操作是将一个新节点插入到二叉树中的特定位置。
插入操作需要考虑节点的大小关系,小于当前节点则插入到左子树,大于当前节点则插入到右子树。
插入操作可以保持二叉树的有序性。
4. 二叉树的删除操作删除操作是将指定节点从二叉树中删除。
删除操作需要考虑被删除节点的子节点情况,如果被删除节点没有子节点,则直接删除;如果有一个子节点,则将子节点替代被删除节点的位置;如果有两个子节点,则选择被删除节点的后继节点或前驱节点替代被删除节点。
5. 二叉树的查找操作查找操作是在二叉树中搜索指定的节点。
二叉树的查找操作可以使用递归或迭代的方式实现。
递归方式会自动遍历整个二叉树,直到找到目标节点或遍历完整个树。
迭代方式则需要手动比较节点的值,并根据大小关系选择左子树或右子树进行进一步查找。
6. 二叉树的平衡性二叉树的平衡性是指左子树和右子树的高度差不超过1。
平衡二叉树可以提高搜索效率,避免出现极端情况下的性能下降。
常见的平衡二叉树有AVL树和红黑树。
7. 二叉树应用场景二叉树在计算机科学中有广泛的应用场景。
例如,文件系统的目录结构可以使用二叉树来表示;数据库中的索引结构也可以使用二叉树来实现。
二叉树的遍历算法实验报告

二叉树的遍历算法实验报告二叉树的遍历算法实验报告引言:二叉树是计算机科学中常用的数据结构之一,它是由节点组成的层次结构,每个节点最多有两个子节点。
在实际应用中,对二叉树进行遍历是一项重要的操作,可以帮助我们理解树的结构和节点之间的关系。
本文将介绍二叉树的三种遍历算法:前序遍历、中序遍历和后序遍历,并通过实验验证其正确性和效率。
一、前序遍历前序遍历是指先访问根节点,然后按照先左后右的顺序遍历左右子树。
具体的实现可以通过递归或者使用栈来实现。
我们以递归方式实现前序遍历算法,并进行实验验证。
实验步骤:1. 创建一个二叉树,并手动构造一些节点和它们之间的关系。
2. 实现前序遍历算法的递归函数,函数的输入为根节点。
3. 在递归函数中,首先访问当前节点,然后递归调用函数遍历左子树,最后递归调用函数遍历右子树。
4. 调用前序遍历函数,输出遍历结果。
实验结果:经过实验,我们得到了正确的前序遍历结果。
这证明了前序遍历算法的正确性。
二、中序遍历中序遍历是指按照先左后根再右的顺序遍历二叉树。
同样,我们可以使用递归或者栈来实现中序遍历算法。
在本实验中,我们选择使用递归方式来实现。
实验步骤:1. 继续使用前面创建的二叉树。
2. 实现中序遍历算法的递归函数,函数的输入为根节点。
3. 在递归函数中,首先递归调用函数遍历左子树,然后访问当前节点,最后递归调用函数遍历右子树。
4. 调用中序遍历函数,输出遍历结果。
实验结果:通过实验,我们得到了正确的中序遍历结果。
这证明了中序遍历算法的正确性。
三、后序遍历后序遍历是指按照先左后右再根的顺序遍历二叉树。
同样,我们可以使用递归或者栈来实现后序遍历算法。
在本实验中,我们选择使用递归方式来实现。
实验步骤:1. 继续使用前面创建的二叉树。
2. 实现后序遍历算法的递归函数,函数的输入为根节点。
3. 在递归函数中,首先递归调用函数遍历左子树,然后递归调用函数遍历右子树,最后访问当前节点。
4. 调用后序遍历函数,输出遍历结果。
二叉树遍历的实习报告
实习报告实习内容:二叉树遍历实习时间:2023实习单位:某高校计算机实验室一、实习目的本次实习的主要目的是通过实现二叉树的遍历,加深对二叉树数据结构的理解,掌握二叉树的常见操作,提高编程能力。
二、实习内容1. 理解二叉树的基本概念和性质,包括节点之间的关系、树的深度、高度等。
2. 掌握二叉树的存储结构,包括顺序存储和链式存储。
3. 实现二叉树的前序遍历、中序遍历和后序遍历。
4. 通过实际编程,验证二叉树遍历的正确性。
三、实习过程1. 二叉树的基本概念和性质:二叉树是一种非线性的数据结构,每个节点最多有两个子节点。
节点之间的关系包括父子关系、兄弟关系等。
树的深度是指从根节点到最远叶子节点的最长路径上的边数,高度是指从根节点到最远叶子节点的最长路径上的边数加1。
2. 二叉树的存储结构:二叉树可以用顺序存储结构或链式存储结构表示。
顺序存储结构使用数组来实现,每个节点存储在数组的一个位置中,节点之间的父子关系通过数组下标来表示。
链式存储结构使用链表来实现,每个节点包含数据域和两个指针域,分别指向左子节点和右子节点。
3. 二叉树的遍历:二叉树的遍历是指按照一定的顺序访问树中的所有节点。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
前序遍历是指先访问根节点,然后递归遍历左子树,最后递归遍历右子树。
中序遍历是指先递归遍历左子树,然后访问根节点,最后递归遍历右子树。
后序遍历是指先递归遍历左子树,然后递归遍历右子树,最后访问根节点。
4. 编程实现:根据二叉树的存储结构和遍历方法,编写C语言程序实现二叉树的前序遍历、中序遍历和后序遍历。
程序中使用递归函数来实现遍历操作,通过建立链式存储结构,验证遍历的正确性。
四、实习心得通过本次实习,我对二叉树的数据结构有了更深入的了解,掌握了二叉树的存储方式和常见操作。
在实现二叉树遍历的过程中,我学会了如何使用递归函数解决问题,提高了编程能力。
同时,通过实际编程验证了二叉树遍历的正确性,增强了对算法理解的信心。
二叉树的各种基本运算的实现实验报告
二叉树的各种基本运算的实现实验报告
一、实验目的
实验目的为了深入学习二叉树的各种基本运算,通过操作实现二叉树的建立、存储、查找、删除、遍历等各种基本运算操作。
二、实验内容
1、构造一个二叉树。
我们首先用一定的节点来构建一棵二叉树,包括节点的左子节点和右子节点。
2、实现查找二叉树中的节点。
在查找二叉树中的节点时,我们根据二叉树的特点,从根节点开始查找,根据要查找的节点的值与根节点的值的大小的关系,来决定接下来查找的方向,直到找到要查找的节点为止。
3、实现删除二叉树中的节点。
在删除二叉树节点时,我们要做的是找到要删除节点的父节点,然后让父节点的链接指向要删除节点的子节点,有可能要删除节点有一个子节点,有可能有两个极点,有可能没有子节点,我们要根据每种情况进行处理,来保持二叉树的结构不变。
4、对二叉树进行遍历操作。
二叉树的遍历有多种方法,本实验使用的是先序遍历。
首先从根节点出发,根据先序遍历的顺序,先访问左子树,然后再访问右子树,最后访问根节点。
三、实验步骤
1、构建二叉树:
我们用一个数组代表要构建的二叉树,第一项为根节点,第二项和第三项是根节点的子节点。
计算机软件实验报告(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、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验三二叉树基本运算以及遍历
一实验目的:
了解树的逻辑和存储特点,掌握二叉树的建立,以及前中后序遍历的理论思想和运算方法。
二实验内容:
建立一棵二叉树,添加树中结点的元素,对该二叉树进行前、中、后序遍历,并打印遍历结果
三实验原理:
二叉树(Binary Tree)是个有限元素的集合,该集合或者为空、或者由一个称为根(root)的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成。
当集合为空时,称该二叉树为空二叉树。
在二叉树中,一个元素也称作一个结点。
二叉树是有序的,即若将其左、右子树颠倒,就成为另一棵不同的二叉树。
即使树中结点只有一棵子树,也要区分它是左子树还是右子树。
即用链来指示着元素的
与rchild分别存放指向左孩子和右孩子的指针,当左孩子或右孩子不存在时,相应指针域值为空。
二叉树的建立:
1 建立根结点。
2 若左子树不空则建左子树。
3 若右子树不空则建右子树。
二叉树的前序遍历
1 访问根结点;
2 先序遍历根结点的左子树;
3 先序遍历根结点的右子树。
二叉树的中序遍历
1 中序遍历根结点的左子树;
2 访问根结点;
3 中序遍历根结点的右子树。
二叉树的后序遍历
1后序遍历根结点的左子树;
2后序遍历根结点的右子树。
3访问根结点;
四实验步骤
1 进入Turbo C2.0,新建一个文件。
2 输入程序,程序要求使用子函数进行组织。
3 将源程序保存到指定文件夹“D:\学生姓名”。
4 按F9调试,纠正语法错误。
5按Ctrl+F9运行,调试逻辑错误。
6 按Alt+F5查看结果。
五、实验中应注意的问题与思考题:
1 如果需要对树中的数据进行查询修改,应该如何实现?
先找到需要修改的数据的位置,再让对其赋值。
2对各个功能模块采用独立编制子函数,增强程序的可执行性、可移植性和可读性。
增加情报信息量,对实际应用中可能发生的情况考虑周全,对非法情形要提出适当的处理方案。
3 深入了解树的逻辑结构,重点掌握递归方法的原理和实现,在确定递归终点条件的时候应特别小心,避免产生死循环。
对树的遍历或处理应该采用递归的方法,尽量不使用非递归算法。
六、源代码
#include "stdio.h"
#include "stdlib.h"
struct btnode
{
int d;
struct btnode *lchild;
struct btnode *rchild;
};
struct btnode *creatbt(bt,k) /*******二叉树的生成********/
struct btnode *bt;
int k;
{
int b;
struct btnode *p,*t;
printf("请输入b: ");
scanf("%d",&b);
if(b!=0)
{
p=(struct btnode *)malloc (sizeof(struct btnode));
p->d=b;p->lchild=NULL;p->rchild=NULL;
if(k==0) t=p;
if(k==1) bt->lchild=p;
if(k==2) bt->rchild=p;
creatbt(p,1);
creatbt(p,2);
}
return(t);
}
pretrav(bt) /********二叉树的前序遍历*****/ struct btnode *bt;
{
if(bt!=NULL)
{
printf("%d ",bt->d);
pretrav(bt->lchild);
pretrav(bt->rchild);
}
return;
}
intrav(bt) /******二叉树的中序遍历*********/ struct btnode *bt;
{
if(bt!=NULL)
{
intrav(bt->lchild);
printf("%d ",bt->d);
intrav(bt->rchild);
}
return;
}
postrav(bt) /*******二叉树的后序遍历*********/ struct btnode *bt;
{
if(bt!=NULL)
{
postrav(bt->lchild);
postrav(bt->rchild);
printf("%d ",bt->d);
}
return;
}
main()
{
struct btnode *bt;
int k;
char i;
bt=(struct btnode *)malloc (sizeof(struct btnode));
k=0;
printf("输入字符'0',退出程序\n");
printf("输入字符'1',生成二叉树\n");
printf("输入字符'2',二叉树的前序遍历\n");
printf("输入字符'3',二叉树的中序遍历\n");
printf("输入字符'4',二叉树的后序遍历\n");
printf("请输入字符'0'-'4': ");
scanf("%s",&i);
for(;i!='0';)
{
switch(i)
{
case '1':
{
bt=creatbt(bt,k);
break;
}
case '2':
{
pretrav(bt);
printf("\n");
break;
}
case '3':
{
intrav(bt);
printf("\n");
break;
}
case '4':
{
postrav(bt);
printf("\n");
break;
}
default:break;
}
printf("输入字符'0',退出程序\n");
printf("输入字符'1',生成二叉树\n");
printf("输入字符'2',二叉树的前序遍历\n");
printf("输入字符'3',二叉树的中序遍历\n");
printf("输入字符'4',二叉树的后序遍历\n");
printf("请输入字符'0'-'4': ");
scanf("%s",&i);
}
free(bt);
}
七、实验总结
了解了树的逻辑和存储特点,掌握了二叉树的建立,以及前中后序遍历的理论思想和运算方法,大大增强了自己的实验上机能力。