实验6二叉树的建立与遍历很好的东西
二叉树的建立与遍历实验报告（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，程序运行了一段时间没有结果，经过检查，发现了这个错误。
二叉树的建立与先序,中序,后序,层次遍历,图的深度优先搜索和广度优先搜索 实验报告
树和图的遍历实验报告2011-4-9实验题目：树和图的遍历实验目的：1.实现二叉树的建立与先序，中序，后序，层次遍历2.选择建立图的类型；根据所选择的类型用邻接矩阵的存储结构构建图；对图进行深度优先搜索和广度优先搜索；实验内容:一、算法描述：（1）二叉树的建立要建立一棵树就要有根节点和两棵子树。
两棵子树的建立同样需要这样的过程。
建立二叉树的过程也是遍历树的过程，实验要求以前序遍历的方式输入数据，因此我们也应按前序遍历的顺序，动态申请存储空间的方式建立这棵树并返回根节点的指针。
BiTNode *CreateBiTree(BiTNode *T){char ch;if((ch=getchar())==' ') T=NULL;else if(ch!='\n'){if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))exit(1);T->data=ch;T->lchild=CreateBiTree(T->lchild);T->rchild=CreateBiTree(T->rchild);}return T;}（2）二叉树的遍历遍历作为二叉树所有操作的基础，因此我把它放在二叉树建立的前面。
前序遍历：即按照根节点，左子树，右子树的顺序访问。
具体操作：遇到节点，立即打印根节点的值，然后访问左子树，再访问右子树。
对左子树和右子树的访问也进行相同的操作。
void PreOrderTraverse(BiTree T){if(T){putchar(T->data);PreOrderTraverse(T->lchild);PreOrderTraverse(T->rchild);}}同理，易得中序遍历，后序遍历的操作。
//中序遍历二叉树void InOrderTraverse(BiTree T){if(T){InOrderTraverse(T->lchild);putchar(T->data);InOrderTraverse(T->rchild);}}//后序遍历二叉树void PostOrderTraverse(BiTree T){if(T){PostOrderTraverse(T->lchild);PostOrderTraverse(T->rchild);putchar(T->data);}}层次遍历：先访问的节点，其孩子节点也必然优先访问，这就用到了队列的思想。
二叉树的建立及其遍历实验报告
数据结构实验报告———二叉树的建立及其遍历一、实验目的1、了解二叉树的建立的方法及其遍历的顺序，熟悉二叉树的三种遍历2、检验输入的数据是否可以构成一颗二叉树二、实验的描述和算法1、实验描述二叉树的建立首先要建立一个二叉链表的结构体，包含根节点和左右子树。
因为耳熟的每一个左右子树又是一颗二叉树，所以可以用递归的方法来建立其左右子树。
二叉树的遍历是一种把二叉树的每一个节点访问完并输出的过程，遍历时根结点与左右孩子的输出顺序构成了不同的遍历方法，这个过程需要按照不同的遍历的方法，先输出根结点还是先输出左右孩子，可以用选择语句实现。
2、算法#include <stdio.h>#include <stdlib.h>#define OVERFLOW 0#define OK 1#define ERROR 0typedef struct BiTNode {char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;BiTree CreateBiTree(BiTree T){scanf("%c",&e);if(e==' ') T=NULL;else {if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))exit(OVERFLOW);T->data=e;T->lchild=CreateBiTree(T->lchild);T->rchild=CreateBiTree(T->rchild);}return T; }/************************前序遍历***********************/ char PreOrderTraverse(BiTree T,char (* Visit)(char e)){if(T){if(Visit(T->data))if(PreOrderTraverse(T->lchild,Visit))if(PreOrderTraverse(T->rchild,Visit)) return OK;return ERROR;}else return OK;}char Visit(char e){printf("%5c",e);return OK;}main(){printf("请输入一颗二叉树，按回车结束：\n");T=CreateBiTree(T);printf("先序遍历的结果：");PreOrderTraverse(T,Visit);}三、调试分析在调这个程序是并没有遇到很大的困难，就是在输入一颗二叉树时，遇到了一点麻烦。
二叉树的建立,二叉树的遍历
数据结构C++实验报告二零一八年一、题目1、实验内容二叉树的建立，二叉树的遍历。
2、实验目的1．进一步掌握指针变量的使用。
2．掌握二叉树的结构特征，以及各种存储结构的特点及使用范围。
3．掌握用指针类型描述、访问和处理二叉树的运算；3、实验题目本实验要求实现以下功能：1．按前序次序建立一颗二叉树，以‘＃’表示空。
2．二叉树采用二叉链表存储，编写计算二叉树最大宽度的算法（二叉树的最大宽度是指二叉树所有层中结点个数的最大值）。
3．以二叉链表作存储结构，编写求二叉树中叶子结点数目的递归函数。
4．试以栈为辅助存储结构实现二叉树的中序非递归算法。
注：4为选做题。
二、程序中使用的数据结构及说明队列栈链表二叉树template<class ElemType>int BinaryTree<ElemType>::Width()const{int lastWidth = 1;int curWidth = 0;//记录上一层和当前层的宽度int treeWidth = 1; //记录树的宽度LinkQueue<BinTreeNode<ElemType>*>q;BinTreeNode<ElemType>*p;if (root != NULL) q.EnQueue(root);while(!q.IsEmpty())//第一个while循环用来层序遍历整个二叉树，第二个while循环用来判断每一行元素是否被读取完{int temWidth = lastWidth;//设置每层结点入队结束的变量，如果temWidth=0说明上一层结点的孩子结点（即该层结点），while (temWidth != 0){q.DelQueue(p);//上一层的结点出队，下一层结点入队，直至上一层结点全部出队if (p->leftChild != NULL)q.EnQueue(p->leftChild);if (p->rightChild != NULL)q.EnQueue(p->rightChild);//结点p的左右结点入队temWidth--;//出队一个元素，temWidth减一}curWidth =q.GetLength();//计算该行的宽度if (treeWidth < curWidth)treeWidth = curWidth;lastWidth = curWidth;//取最大值}return treeWidth;}三、源代码#include"pch.h"#include<iostream>using namespace std;enum Status { SUCCESS, OVER_FLOW, RANGE_ERROR, NOT_PRESENT, ENTRY_FOUND, UNDER_FLOW };//成功，越界，范围错误,未找到const int MaxSize = 50;template<class ElemType>struct Node{ElemType data;Node<ElemType>*next;Node();//普通构造函数Node(ElemType e, Node<ElemType>*link = NULL);//带形参的构造函数};template<class ElemType>Node<ElemType>::Node(){next = NULL;}template<class ElemType>Node<ElemType>::Node(ElemType e, Node<ElemType>*link){data = e;next = link;}template<class ElemType>class LinkQueue{protected:Node<ElemType> *front, *rear; // 队头队尾指针public:LinkQueue();virtual ~LinkQueue();int GetLength() const;bool IsEmpty() const;void Clear();Status DelQueue(ElemType &e);Status GetHead(ElemType &e) const;Status EnQueue(const ElemType e);};template<class ElemType>LinkQueue<ElemType>::LinkQueue(){rear = front = new Node<ElemType>;}template<class ElemType>LinkQueue<ElemType>::~LinkQueue(){Clear();delete front;}template<class ElemType>int LinkQueue<ElemType>::GetLength() const{int count = 0;Node<ElemType> *p;for (p = front->next; p != NULL; p = p->next) count++;return count;}template<class ElemType>bool LinkQueue<ElemType>::IsEmpty() const{return rear == front;}template<class ElemType>void LinkQueue<ElemType>::Clear(){Node<ElemType> *p = front->next;while (p != NULL){front->next = p->next;delete p;p = front->next;}rear = front;}template<class ElemType>Status LinkQueue<ElemType>::EnQueue(const ElemType e) {Node<ElemType> *p;p = new Node<ElemType>(e);if (p){rear->next = p;rear = rear->next;return SUCCESS;}else return OVER_FLOW;}template<class ElemType>Status LinkQueue<ElemType>::GetHead(ElemType &e) const {if (!IsEmpty()){e = front->next->data;return SUCCESS;}else return UNDER_FLOW;}template<class ElemType>Status LinkQueue<ElemType>::DelQueue(ElemType &e) {if (!IsEmpty()){Node<ElemType> *p = front->next;e = p->data;front->next = p->next;if (rear == p)rear = front;//队列中只有一个元素delete p;return SUCCESS;}else return UNDER_FLOW;}template<class ElemType>struct BinTreeNode{ElemType data;BinTreeNode<ElemType>*leftChild;BinTreeNode<ElemType>*rightChild;BinTreeNode();BinTreeNode(const ElemType &d, BinTreeNode<ElemType> *lChild, BinTreeNode<ElemType> *rChild);};template<class ElemType>BinTreeNode<ElemType>::BinTreeNode(){leftChild = rightChild = NULL;}template <class ElemType>BinTreeNode<ElemType>::BinTreeNode(const ElemType &d, BinTreeNode<ElemType> *lChild, BinTreeNode<ElemType> *rChild){data = d; // 数据元素值leftChild = lChild; // 左孩子rightChild = rChild; // 右孩子}template<class ElemType>class BinaryTree{protected:BinTreeNode<ElemType>*root;public:void CreateBinaryTree();void CreateBinaryTree(BinTreeNode<ElemType> * & r);BinTreeNode<ElemType>*GetRoot()const;//求二叉树的根void PreOrder(BinTreeNode<ElemType>*r, void(*Visit)(const ElemType&))const;//先序遍历以r为根的二叉树void PreOrder(void(*Visit)(const ElemType&))const;//先序遍历整棵二叉树void InOrder(BinTreeNode<ElemType>*r, void(*Visit)(const ElemType&))const;//中序遍历以r为根的二叉树void InOrder(void(*Visit)(const ElemType&))const;//中序遍历整棵二叉树void LevelOrder(void(*Visit)(const ElemType&))const;int Width()const;int CountLeaf(BinTreeNode<ElemType>*r)const;};template<class ElemType>void BinaryTree<ElemType>::CreateBinaryTree(BinTreeNode<ElemType> * & r){ElemType ch;cin >> ch;if (ch == '#') r = NULL;else{r = new BinTreeNode <ElemType>;r->data = ch;CreateBinaryTree(r->leftChild);CreateBinaryTree(r->rightChild);}}template<class ElemType>void BinaryTree<ElemType>::CreateBinaryTree(){CreateBinaryTree(root);}template<class ElemType>BinTreeNode<ElemType>* BinaryTree<ElemType>::GetRoot()const{return root;}template<class ElemType>void BinaryTree<ElemType>::PreOrder(BinTreeNode<ElemType>*r, void(*Visit)(const ElemType&))const{if (r != NULL){(*Visit)(r->data);PreOrder(r->leftChild, Visit);PreOrder(r->rightChild, Visit);}}template <class ElemType>void BinaryTree<ElemType>::PreOrder(void(*Visit)(const ElemType &)) const{PreOrder(root, Visit);}template<class ElemType>void BinaryTree<ElemType>::InOrder(BinTreeNode<ElemType>*r, void(*Visit)(const ElemType&))const{if (r != NULL){InOrder(r->leftChild, Visit);(*Visit)(r->data);InOrder(r->rightChild, Visit);}}template <class ElemType>void BinaryTree<ElemType>::InOrder(void(*Visit)(const ElemType &)) const{InOrder(root, Visit);}template<class ElemType>void BinaryTree<ElemType>::LevelOrder(void(*Visit)(const ElemType &)) const{LinkQueue<BinTreeNode<ElemType>*>q;BinTreeNode<ElemType>*p;//用来返回出队元素if (root != NULL) q.EnQueue(root);while (!q.IsEmpty()){q.DelQueue(p);(*Visit)(p->data);if (p->leftChild != NULL)q.EnQueue(p->leftChild);if (p->rightChild != NULL)q.EnQueue(p->rightChild);}}template<class ElemType>int BinaryTree<ElemType>::Width()const{int lastWidth = 1;int curWidth = 0;//记录上一层和当前层的宽度int treeWidth = 1;LinkQueue<BinTreeNode<ElemType>*>q;BinTreeNode<ElemType>*p;if (root != NULL) q.EnQueue(root);while(!q.IsEmpty())//第一个while循环用来层序遍历整个二叉树，第二个while循环用来判断每一行元素是否被读取完{int temWidth = lastWidth;while (temWidth != 0){q.DelQueue(p);if (p->leftChild != NULL)q.EnQueue(p->leftChild);if (p->rightChild != NULL)q.EnQueue(p->rightChild);temWidth--;}curWidth = q.GetLength();if (treeWidth < curWidth)treeWidth = curWidth;lastWidth = curWidth;}return treeWidth;}template<class ElemType>int BinaryTree<ElemType>::CountLeaf(BinTreeNode<ElemType>*r)const {int Leaf = 0;int lLeaf = 0;int rLeaf = 0;if (r == NULL)return 0;if (r->leftChild == NULL && r->rightChild == NULL)return 1;else{lLeaf = CountLeaf(r->leftChild);rLeaf = CountLeaf(r->rightChild);Leaf = lLeaf + rLeaf;return Leaf;}}template<class ElemType>void Display(const ElemType &e){cout << e << " ";}void main(void){BinaryTree<char> tree;cout <<"请输入二叉树的先序序列，#表示空指针："<< endl;tree.CreateBinaryTree();cout <<"二叉树的先序序列为：";tree.PreOrder(Display);cout << endl;cout <<"二叉树的中序序列为：";tree.InOrder(Display);cout << endl;cout <<"二叉树的最大宽度为："<< tree.Width() << endl;cout <<"二叉树的叶子节点数目为："<< tree.CountLeaf(tree.GetRoot()) << endl;system("pause");}四、程序运行时的初值和运行结果以及二叉树的形态请输入二叉树的先序序列，#表示空指针：ABDG#L##HM###EIN##O###C#FJ##K##二叉树的先序序列为：A B D G L H M E I N O C F J K二叉树的中序序列为：G L D M H B N I O E A C J F K二叉树的最大宽度为：5二叉树的叶子节点数目为：6请按任意键继续. . .二叉树形态：。
二叉树的建立和遍历的实验报告doc
二叉树的建立和遍历的实验报告篇一：二叉树的建立及遍历实验报告实验三：二叉树的建立及遍历【实验目的】（1）掌握利用先序序列建立二叉树的二叉链表的过程。
（2）掌握二叉树的先序、中序和后序遍历算法。
【实验内容】1. 编写程序，实现二叉树的建立，并实现先序、中序和后序遍历。
如：输入先序序列abc###de###，则建立如下图所示的二叉树。
并显示其先序序列为：abcde中序序列为：cbaed后序序列为：cbeda【实验步骤】1.打开VC++。
2.建立工程：点File->New，选Project标签，在列表中选Win32 Console Application，再在右边的框里为工程起好名字，选好路径，点OK->finish。
至此工程建立完毕。
3.创建源文件或头文件：点File->New，选File标签，在列表里选C++ Source File。
给文件起好名字，选好路径，点OK。
至此一个源文件就被添加到了你刚创建的工程之中。
4．写好代码5．编译－＞链接－＞调试#include#include#define OK 1#define OVERFLOW -2typedef int Status;typedef char TElemType;typedef struct BiTNode{TElemType data;struct BiTNode *lchild, *rchild;}BiTNode,*BiTree;Status CreateBiTree(BiTree &T){TElemType ch;scanf("%c",&ch);if (ch=='#')T= NULL;else{if (!(T = (BiTNode *)malloc(sizeof(BiTNode))))return OVERFLOW;T->data = ch; CreateBiTree(T->lchild); CreateBiTree(T->rchild); }return OK;} // CreateBiTreevoid PreOrder(BiTree T) {if(T){printf("%c",T->data); PreOrder(T->lchild); PreOrder(T->rchild);}}void InOrder(BiTree T) {if(T){InOrder(T->lchild);printf("%c",T->data);InOrder(T->rchild);}}void PostOrder(BiTree T){if(T){PostOrder(T->lchild); PostOrder(T->rchild);printf("%c",T->data);}}void main(){BiTree T;CreateBiTree(T);printf("\n先序遍历序列:"); PreOrder(T);printf("\n中序遍历序列:"); InOrder(T);printf("\n后序遍历序列:"); PostOrder(T);}【实验心得】这次实验主要是通过先序序列建立二叉树，和二叉树的先序、中序、后续遍历算法。
二叉树的遍历算法实验报告
二叉树的遍历算法实验报告二叉树的遍历算法实验报告引言：二叉树是计算机科学中常用的数据结构之一，它是由节点组成的层次结构，每个节点最多有两个子节点。
在实际应用中，对二叉树进行遍历是一项重要的操作，可以帮助我们理解树的结构和节点之间的关系。
本文将介绍二叉树的三种遍历算法：前序遍历、中序遍历和后序遍历，并通过实验验证其正确性和效率。
一、前序遍历前序遍历是指先访问根节点，然后按照先左后右的顺序遍历左右子树。
具体的实现可以通过递归或者使用栈来实现。
我们以递归方式实现前序遍历算法，并进行实验验证。
实验步骤：1. 创建一个二叉树，并手动构造一些节点和它们之间的关系。
2. 实现前序遍历算法的递归函数，函数的输入为根节点。
3. 在递归函数中，首先访问当前节点，然后递归调用函数遍历左子树，最后递归调用函数遍历右子树。
4. 调用前序遍历函数，输出遍历结果。
实验结果：经过实验，我们得到了正确的前序遍历结果。
这证明了前序遍历算法的正确性。
二、中序遍历中序遍历是指按照先左后根再右的顺序遍历二叉树。
同样，我们可以使用递归或者栈来实现中序遍历算法。
在本实验中，我们选择使用递归方式来实现。
实验步骤：1. 继续使用前面创建的二叉树。
2. 实现中序遍历算法的递归函数，函数的输入为根节点。
3. 在递归函数中，首先递归调用函数遍历左子树，然后访问当前节点，最后递归调用函数遍历右子树。
4. 调用中序遍历函数，输出遍历结果。
实验结果：通过实验，我们得到了正确的中序遍历结果。
这证明了中序遍历算法的正确性。
三、后序遍历后序遍历是指按照先左后右再根的顺序遍历二叉树。
同样，我们可以使用递归或者栈来实现后序遍历算法。
在本实验中，我们选择使用递归方式来实现。
实验步骤：1. 继续使用前面创建的二叉树。
2. 实现后序遍历算法的递归函数，函数的输入为根节点。
3. 在递归函数中，首先递归调用函数遍历左子树，然后递归调用函数遍历右子树，最后访问当前节点。
4. 调用后序遍历函数，输出遍历结果。
二叉树存储结构的建立、遍历和应用
二叉树存储结构的建立、遍历和应用一、二叉树存储结构的建立在二叉树的存储结构中，常见的有顺序存储和链式存储两种方式。
1. 顺序存储方式：顺序存储是利用数组来存储二叉树，通常按照层次遍历的顺序将节点依次存放在数组中。
对于完全二叉树来说，可以使用数组来存储，因为完全二叉树的节点是按照从上到下、从左到右的顺序依次排列的。
2. 链式存储方式：链式存储是通过定义一个二叉树节点的结构体，其中包含左子节点指针、右子节点指针以及节点值等信息。
通过将节点按照某种遍历方式连接起来，形成一棵二叉树。
二、二叉树的遍历方式二叉树的遍历方式包括前序遍历、中序遍历和后序遍历，它们的区别在于遍历节点的顺序不同。
1. 前序遍历：前序遍历是先访问根节点，然后递归地遍历左子树，最后再递归地遍历右子树。
前序遍历的顺序是先根节点，再左子树，最后右子树。
2. 中序遍历：中序遍历是先递归地遍历左子树，然后访问根节点，最后再递归地遍历右子树。
中序遍历的顺序是先左子树，再根节点，最后右子树。
3. 后序遍历：后序遍历是先递归地遍历左子树，然后递归地遍历右子树，最后访问根节点。
后序遍历的顺序是先左子树，再右子树，最后根节点。
三、二叉树的应用二叉树在实际应用中有很多场景，下面介绍其中几个常见的例子。
1. 表达式求值：二叉树可以用来表示数学表达式，其中根节点是运算符，左子树是左操作数，右子树是右操作数。
通过遍历二叉树，可以对表达式进行求值。
2. 文件系统：文件系统可以使用二叉树来表示目录结构，每个节点表示一个文件或者文件夹，左子节点表示当前文件夹下的文件或子文件夹。
通过遍历二叉树，可以实现对文件系统的管理和查找。
3. 排序算法：二叉树可以用来实现排序算法，例如二叉查找树（BST）就是一种常用的排序算法。
通过构建一个满足特定条件的二叉树，可以实现高效的查找、插入和删除操作。
4. Huffman编码：Huffman编码是一种常用的数据压缩算法，它通过构建一棵Huffman树来实现对数据的压缩和解压缩。
计算机软件实验报告(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）掌握二叉树的遍历算法（先序、中序、后序遍历算法）的思想，并学会遍历算法的递归实现和非递归实现。
二、实验内容：构造二叉树，再实现二叉树的先序、中序、后序遍历，最后统计二叉树的深度。
三、实验步骤：(一) 需求分析1. 二叉树的建立首先要建立一个二叉链表的结构体，包含根节点和左右子树。
因为树的每一个左右子树又是一颗二叉树，所以用递归的方法来建立其左右子树。
二叉树的遍历是一种把二叉树的每一个节点访问并输出的过程，遍历时根结点与左右孩子的输出顺序构成了不同的遍历方法，这个过程需要按照不同的遍历的方法，先输出根结点还是先输出左右孩子，可以用选择语句来实现。
2．程序的执行命令为：1）构造结点类型，然后创建二叉树。
2）根据提示，从键盘输入各个结点。
3）通过选择一种方式（先序、中序或者后序）遍历。
4）输出结果，结束。
(二)概要设计1.二叉树的二叉链表结点存储类型定义typedef struct Node{DataType data;struct Node *LChild;struct Node *RChild;}BitNode,*BitTree;2.建立如下图所示二叉树：void CreatBiTree(BitTree *bt)用扩展先序遍历序列创建二叉树，如果是当前树根置为空，否则申请一个新节点。
3.本程序包含四个模块1) 主程序模块：2)先序遍历模块3)中序遍历模块4)后序遍历模块4.（三）详细设计1.建立二叉树存储类型//==========构造二叉树=======void CreatBiTree(BitTree *bt)//用扩展先序遍历序列创建二叉树，如果是当前树根置为空，否则申请一个新节点//{char ch;ch=getchar();if(ch=='.')*bt=NULL;else{*bt=(BitTree)malloc(sizeof(BitNode));//申请一段关于该节点类型的存储空间(*bt)->data=ch; //生成根结点CreatBiTree(&((*bt)->LChild)); //构造左子树CreatBiTree(&((*bt)->RChild)); //构造右子树}}2.编程实现以上二叉树的前序、中序和后序遍历操作，输出遍历序列1）先序遍历二叉树的递归算法如下：void PreOrder(BitTree root){if (root!=NULL){Visit(root ->data);PreOrder(root ->LChild); //递归调用核心PreOrder(root ->RChild);}}2）中序遍历二叉树的递归算法如下：void InOrder(BitTree root){if (root!=NULL){InOrder(root ->LChild);Visit(root ->data);InOrder(root ->RChild);}}3）后序遍历二叉树的递归算法如下：void PostOrder(BitTree root){if(root!=NULL){PostOrder(root ->LChild);PostOrder(root ->RChild);Visit(root ->data);}}4）计算二叉树的深度算法如下：int PostTreeDepth(BitTree bt) //求二叉树的深度{int hl,hr,max;if(bt!=NULL){hl=PostTreeDepth(bt->LChild); //求左子树的深度hr=PostTreeDepth(bt->RChild); //求右子树的深度max=hl>hr?hl:hr; //得到左、右子树深度较大者return(max+1); //返回树的深度}else return(0); //如果是空树，则返回0}四、调试分析及测试结果1. 进入演示程序后的显示主界面：请输入二叉树中的元素；先序、中序和后序遍历分别输出结果。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验6 二叉树的建立与遍历操作
科目：数据结构实验和课程设计班级：姓名：学号：
实验目的：
熟悉C语言程序的基本结构，掌握程序中的用户头文件、文件之间的相互关系及各自的作用。
熟悉C语言操作环境的使用以及多文件程序的输入、编辑、调试和运行的全过程。
加深理解二叉树的二叉链表表示的意义，理解二叉树的建立过程，熟悉二叉树的链式存储和遍历算法、三种遍历的递归和非递归算法及层次遍历算法。
实验设备：
每人一台安装VC6.0编写软件的计算机，公用打印机。
实验要求：
1 对二叉树的二叉链表存储结构进行类型定义
2 编写二叉树各种基本运算算法，
void CreateBTNode(BTNode *&b,char *str);由str串创建二叉链表
BTNode *FindNode(BTNode *b,ElemType x);返回data域为x的结点指针
BTNode *LchildNode(BTNode *p);返回*p结点的左孩子结点指针
BTNode *RchildNode(BTNode *p); 返回*p结点的右孩子结点指针
int BTNodeDepth(BTNode *b);求二叉树b的深度
void DispBTNode(BTNode *b);以括号表示法输出二叉树
int Nodes(BTNode *b); 求二叉树b的结点个数
int LeafNodes(BTNode *b); 求二叉树b的叶子结点个数
3 在此基础上设计一个主程序完成如下功能：
（1）输出二叉树b
（2）输出‘H’结点的左、右孩子结点的值
（3）输出二叉树b的深度
（4）输出二叉树b的结点个数
（5）输出二叉树b的叶子结点个数
4 编写二叉树三种遍历的递归非递归算法及层次遍历算法
PreOrder(BTNode *b)：先序递归算法；PreOrder1(BTNode *b)：先序非递归算法
InOrder(BTNode *b)：中序递归算法；InOrder1(BTNode *b)：中序非递归算法
PostOrder(BTNode *b)：后序递归算法；PostOrder1(BTNode *b)：后序非递归算法；
TravLevel(BTNode *b)：层次遍历算法
5 编写主程序验证二叉树的各种遍历算法，并对相应的输出作出分析；加深对各种遍历算法的理解。
实验步骤：。