创建一个二叉树并输出三种遍历结果
二叉树的建立与基本操作
二叉树的建立与基本操作二叉树是一种特殊的树形结构，它由节点（node）组成，每个节点最多有两个子节点。
二叉树的基本操作包括建立二叉树、遍历二叉树、查找二叉树节点、插入和删除节点等。
本文将详细介绍二叉树的建立和基本操作，并给出相应的代码示例。
一、建立二叉树建立二叉树有多种方法，包括使用数组、链表和前序、中序、后序遍历等。
下面以使用链表的方式来建立二叉树为例。
1.定义二叉树节点类首先，定义一个二叉树节点的类，包含节点值、左子节点和右子节点三个属性。
```pythonclass Node:def __init__(self, value):self.value = valueself.left = Noneself.right = None```2.建立二叉树使用递归的方法来建立二叉树，先构造根节点，然后递归地构造左子树和右子树。
```pythondef build_binary_tree(lst):if not lst: # 如果 lst 为空，则返回 Nonereturn Nonemid = len(lst) // 2 # 取 lst 的中间元素作为根节点的值root = Node(lst[mid])root.left = build_binary_tree(lst[:mid]) # 递归构造左子树root.right = build_binary_tree(lst[mid+1:]) # 递归构造右子树return root```下面是建立二叉树的示例代码：```pythonlst = [1, 2, 3, 4, 5, 6, 7]root = build_binary_tree(lst)```二、遍历二叉树遍历二叉树是指按照其中一规则访问二叉树的所有节点，常见的遍历方式有前序遍历、中序遍历和后序遍历。
1.前序遍历前序遍历是指先访问根节点，然后访问左子节点，最后访问右子节点。
```pythondef pre_order_traversal(root):if root:print(root.value) # 先访问根节点pre_order_traversal(root.left) # 递归访问左子树pre_order_traversal(root.right) # 递归访问右子树```2.中序遍历中序遍历是指先访问左子节点，然后访问根节点，最后访问右子节点。
二叉树的遍历及常用算法
⼆叉树的遍历及常⽤算法⼆叉树的遍历及常⽤算法遍历的定义:按照某种次序访问⼆叉树上的所有结点,且每个节点仅被访问⼀次;遍历的重要性:当我们需要对⼀颗⼆叉树进⾏,插⼊,删除,查找等操作时,通常都需要先遍历⼆叉树,所有说:遍历是⼆叉树的基本操作;遍历思路:⼆叉树的数据结构是递归定义(每个节点都可能包含相同结构的⼦节点),所以遍历也可以使⽤递归,即结点不为空则继续递归调⽤每个节点都有三个域,数据与,左孩⼦指针和右孩⼦之指针,每次遍历只需要读取数据,递归左⼦树,递归右⼦树,这三个操作三种遍历次序:根据访问三个域的不同顺序,可以有多种不同的遍历次序,⽽通常对于⼦树的访问都按照从左往右的顺序;设:L为遍历左⼦树,D为访问根结点,R为遍历右⼦树,且L必须位于R的前⾯可以得出以下三种不同的遍历次序:先序遍历操作次序为DLR,⾸先访问根结点，其次遍历根的左⼦树，最后遍历根右⼦树，对每棵⼦树同样按这三步(先根、后左、再右)进⾏中序遍历操作次序为LDR,⾸先遍历根的左⼦树，其次访问根结点，最后遍历根右⼦树，对每棵⼦树同样按这三步(先左、后根、再右)进⾏后序遍历操作次序为LRD,⾸先遍历根的左⼦树，其次遍历根的右⼦树，最后访问根结点，对每棵⼦树同样按这三步(先左、后右、最后根)进⾏层次遍历层次遍历即按照从上到下从左到右的顺序依次遍历所有节点,实现层次遍历通常需要借助⼀个队列,将接下来要遍历的结点依次加⼊队列中;遍历的应⽤“遍历”是⼆叉树各种操作的基础，可以在遍历过程中对结点进⾏各种操作，如:对于⼀棵已知⼆叉树求⼆叉树中结点的个数求⼆叉树中叶⼦结点的个数;求⼆叉树中度为1的结点个数求⼆叉树中度为2的结点个数5求⼆叉树中⾮终端结点个数交换结点左右孩⼦判定结点所在层次等等...C语⾔实现:#include <stdio.h>//⼆叉链表数据结构定义typedef struct TNode {char data;struct TNode *lchild;struct TNode *rchild;} *BinTree, BinNode;//初始化//传⼊⼀个指针令指针指向NULLvoid initiate(BinTree *tree) {*tree = NULL;}//创建树void create(BinTree *BT) {printf("输⼊当前结点值: (0则创建空节点)\n");char data;scanf(" %c", &data);//连续输⼊整形和字符时.字符变量会接受到换⾏,所以加空格if (data == 48) {*BT = NULL;return;} else {//创建根结点//注意开辟的空间⼤⼩是结构体的⼤⼩⽽不是结构体指针⼤⼩,写错了不会⽴马产⽣问题,但是后续在其中存储数据时极有可能出现内存访问异常(飙泪....) *BT = malloc(sizeof(struct TNode));//数据域赋值(*BT)->data = data;printf("输⼊节点 %c 的左孩⼦ \n", data);create(&((*BT)->lchild));//递归创建左⼦树printf("输⼊节点 %c 的右孩⼦ \n", data);create(&((*BT)->rchild));//递归创建右⼦树}}//求双亲结点(⽗结点)BinNode *Parent(BinTree tree, char x) {if (tree == NULL)return NULL;else if ((tree->lchild != NULL && tree->lchild->data == x) || (tree->rchild != NULL && tree->rchild->data == x))return tree;else{BinNode *node1 = Parent(tree->lchild, x);BinNode *node2 = Parent(tree->rchild, x);return node1 != NULL ? node1 : node2;}}//先序遍历void PreOrder(BinTree tree) {if (tree) {//输出数据printf("%c ", tree->data);//不为空则按顺序继续递归判断该节点的两个⼦节点PreOrder(tree->lchild);PreOrder(tree->rchild);}}//中序void InOrder(BinTree tree) {if (tree) {InOrder(tree->lchild);printf("%c ", tree->data);InOrder(tree->rchild);}}//后序void PostOrder(BinTree tree) {if (tree) {PostOrder(tree->lchild);PostOrder(tree->rchild);printf("%c ", tree->data);}}//销毁结点递归free所有节点void DestroyTree(BinTree *tree) {if (*tree != NULL) {printf("free %c \n", (*tree)->data);if ((*tree)->lchild) {DestroyTree(&((*tree)->lchild));}if ((*tree)->rchild) {DestroyTree(&((*tree)->rchild));}free(*tree);*tree = NULL;}}// 查找元素为X的结点使⽤的是层次遍历BinNode *FindNode(BinTree tree, char x) {if (tree == NULL) {return NULL;}//队列BinNode *nodes[1000] = {};//队列头尾位置int front = 0, real = 0;//将根节点插⼊到队列尾nodes[real] = tree;real += 1;//若队列不为空则继续while (front != real) {//取出队列头结点输出数据BinNode *current = nodes[front];if (current->data == x) {return current;}front++;//若当前节点还有⼦(左/右)节点则将结点加⼊队列if (current->lchild != NULL) {nodes[real] = current->lchild;real++;}if (current->rchild != NULL) {nodes[real] = current->rchild;real++;}}return NULL;}//层次遍历// 查找元素为X的结点使⽤的是层次遍历void LevelOrder(BinTree tree) {if (tree == NULL) {return;}//队列BinNode *nodes[1000] = {};//队列头尾位置int front = 0, real = 0;//将根节点插⼊到队列尾nodes[real] = tree;real += 1;//若队列不为空则继续while (front != real) {//取出队列头结点输出数据BinNode *current = nodes[front];printf("%2c", current->data);front++;//若当前节点还有⼦(左/右)节点则将结点加⼊队列if (current->lchild != NULL) {nodes[real] = current->lchild;real++;}if (current->rchild != NULL) {nodes[real] = current->rchild;real++;}}}//查找x的左孩⼦BinNode *Lchild(BinTree tree, char x) {BinTree node = FindNode(tree, x);if (node != NULL) {return node->lchild;}return NULL;}//查找x的右孩⼦BinNode *Rchild(BinTree tree, char x) {BinTree node = FindNode(tree, x);if (node != NULL) {return node->rchild;}return NULL;}//求叶⼦结点数量int leafCount(BinTree *tree) {if (*tree == NULL)return 0;//若左右⼦树都为空则该节点为叶⼦,且后续不⽤接续递归了else if (!(*tree)->lchild && !(*tree)->rchild)return 1;else//若当前结点存在⼦树,则递归左右⼦树, 结果相加return leafCount(&((*tree)->lchild)) + leafCount(&((*tree)->rchild));}//求⾮叶⼦结点数量int NotLeafCount(BinTree *tree) {if (*tree == NULL)return 0;//若该结点左右⼦树均为空,则是叶⼦,且不⽤继续递归else if (!(*tree)->lchild && !(*tree)->rchild)return 0;else//若当前结点存在左右⼦树,则是⾮叶⼦结点(数量+1),在递归获取左右⼦树中的⾮叶⼦结点,结果相加 return NotLeafCount(&((*tree)->lchild)) + NotLeafCount(&((*tree)->rchild)) + 1;}//求树的⾼度(深度)int DepthCount(BinTree *tree) {if (*tree == NULL)return 0;else{//当前节点不为空则深度+1 在加上⼦树的⾼度,int lc = DepthCount(&((*tree)->lchild)) + 1;int rc = DepthCount(&((*tree)->rchild)) + 1;return lc > rc?lc:rc;// 取两⼦树深度的最⼤值 }}//删除左⼦树void RemoveLeft(BinNode *node){if (!node)return;if (node->lchild)DestroyTree(&(node->lchild));node->lchild = NULL;}//删除右⼦树void RemoveRight(BinNode *node){if (!node)return;if (node->rchild)DestroyTree(&(node->rchild));node->rchild = NULL;}int main() {BinTree tree;create(&tree);BinNode *node = Parent(tree, 'G');printf("G的⽗结点为%c\n",node->data);BinNode *node2 = Lchild(tree, 'D');printf("D的左孩⼦结点为%c\n",node2->data);BinNode *node3 = Rchild(tree, 'D');printf("D的右孩⼦结点为%c\n",node3->data);printf("先序遍历为:");PreOrder(tree);printf("\n");printf("中序遍历为:");InOrder(tree);printf("\n");printf("后序遍历为:");PostOrder(tree);printf("\n");printf("层次遍历为:");LevelOrder(tree);printf("\n");int a = leafCount(&tree);printf("叶⼦结点数为%d\n",a);int b = NotLeafCount(&tree);printf("⾮叶⼦结点数为%d\n",b);int c = DepthCount(&tree);printf("深度为%d\n",c);//查找F节点BinNode *node4 = FindNode(tree,'C');RemoveLeft(node4);printf("删除C的左孩⼦后遍历:");LevelOrder(tree);printf("\n");RemoveRight(node4);printf("删除C的右孩⼦后遍历:");LevelOrder(tree);printf("\n");//销毁树printf("销毁树 \n");DestroyTree(&tree);printf("销毁后后遍历:");LevelOrder(tree);printf("\n");printf("Hello, World!\n");return 0;}测试:测试数据为下列⼆叉树:运⾏程序复制粘贴下列内容:ABDGHECKFIJ特别感谢:iammomo。
二叉树遍历（前序、中序、后序、层次、广度优先、深度优先遍历）
⼆叉树遍历（前序、中序、后序、层次、⼴度优先、深度优先遍历）⽬录转载：⼆叉树概念⼆叉树是⼀种⾮常重要的数据结构，⾮常多其他数据结构都是基于⼆叉树的基础演变⽽来的。
对于⼆叉树，有深度遍历和⼴度遍历，深度遍历有前序、中序以及后序三种遍历⽅法，⼴度遍历即我们寻常所说的层次遍历。
由于树的定义本⾝就是递归定义，因此採⽤递归的⽅法去实现树的三种遍历不仅easy理解并且代码⾮常简洁，⽽对于⼴度遍历来说，须要其他数据结构的⽀撑。
⽐⽅堆了。
所以。
对于⼀段代码来说，可读性有时候要⽐代码本⾝的效率要重要的多。
四种基本的遍历思想前序遍历：根结点 ---> 左⼦树 ---> 右⼦树中序遍历：左⼦树---> 根结点 ---> 右⼦树后序遍历：左⼦树 ---> 右⼦树 ---> 根结点层次遍历：仅仅需按层次遍历就可以⽐如。
求以下⼆叉树的各种遍历前序遍历：1 2 4 5 7 8 3 6中序遍历：4 2 7 5 8 1 3 6后序遍历：4 7 8 5 2 6 3 1层次遍历：1 2 3 4 5 6 7 8⼀、前序遍历1）依据上⽂提到的遍历思路：根结点 ---> 左⼦树 ---> 右⼦树，⾮常easy写出递归版本号：public void preOrderTraverse1(TreeNode root) {if (root != null) {System.out.print(root.val+" ");preOrderTraverse1(root.left);preOrderTraverse1(root.right);}}2）如今讨论⾮递归的版本号：依据前序遍历的顺序，优先訪问根结点。
然后在訪问左⼦树和右⼦树。
所以。
对于随意结点node。
第⼀部分即直接訪问之，之后在推断左⼦树是否为空，不为空时即反复上⾯的步骤，直到其为空。
若为空。
则须要訪问右⼦树。
注意。
在訪问过左孩⼦之后。
二叉树的遍历算法实验报告
二叉树的遍历算法实验报告二叉树的遍历算法实验报告引言：二叉树是计算机科学中常用的数据结构之一，它是由节点组成的层次结构，每个节点最多有两个子节点。
在实际应用中，对二叉树进行遍历是一项重要的操作，可以帮助我们理解树的结构和节点之间的关系。
本文将介绍二叉树的三种遍历算法：前序遍历、中序遍历和后序遍历，并通过实验验证其正确性和效率。
一、前序遍历前序遍历是指先访问根节点，然后按照先左后右的顺序遍历左右子树。
具体的实现可以通过递归或者使用栈来实现。
我们以递归方式实现前序遍历算法，并进行实验验证。
实验步骤：1. 创建一个二叉树，并手动构造一些节点和它们之间的关系。
2. 实现前序遍历算法的递归函数，函数的输入为根节点。
3. 在递归函数中，首先访问当前节点，然后递归调用函数遍历左子树，最后递归调用函数遍历右子树。
4. 调用前序遍历函数，输出遍历结果。
实验结果：经过实验，我们得到了正确的前序遍历结果。
这证明了前序遍历算法的正确性。
二、中序遍历中序遍历是指按照先左后根再右的顺序遍历二叉树。
同样，我们可以使用递归或者栈来实现中序遍历算法。
在本实验中，我们选择使用递归方式来实现。
实验步骤：1. 继续使用前面创建的二叉树。
2. 实现中序遍历算法的递归函数，函数的输入为根节点。
3. 在递归函数中，首先递归调用函数遍历左子树，然后访问当前节点，最后递归调用函数遍历右子树。
4. 调用中序遍历函数，输出遍历结果。
实验结果：通过实验，我们得到了正确的中序遍历结果。
这证明了中序遍历算法的正确性。
三、后序遍历后序遍历是指按照先左后右再根的顺序遍历二叉树。
同样，我们可以使用递归或者栈来实现后序遍历算法。
在本实验中，我们选择使用递归方式来实现。
实验步骤：1. 继续使用前面创建的二叉树。
2. 实现后序遍历算法的递归函数，函数的输入为根节点。
3. 在递归函数中，首先递归调用函数遍历左子树，然后递归调用函数遍历右子树，最后访问当前节点。
4. 调用后序遍历函数，输出遍历结果。
二叉树遍历（前中后序遍历，三种方式）
⼆叉树遍历（前中后序遍历，三种⽅式）⽬录刷题中碰到⼆叉树的遍历，就查找了⼆叉树遍历的⼏种思路，在此做个总结。
对应的LeetCode题⽬如下：，，，接下来以前序遍历来说明三种解法的思想，后⾯中序和后续直接给出代码。
⾸先定义⼆叉树的数据结构如下：//Definition for a binary tree node.struct TreeNode {int val;TreeNode *left;TreeNode *right;TreeNode(int x) : val(x), left(NULL), right(NULL) {}};前序遍历，顺序是“根-左-右”。
使⽤递归实现：递归的思想很简单就是我们每次访问根节点后就递归访问其左节点，左节点访问结束后再递归的访问右节点。
代码如下：class Solution {public:vector<int> preorderTraversal(TreeNode* root) {if(root == NULL) return {};vector<int> res;helper(root,res);return res;}void helper(TreeNode *root, vector<int> &res){res.push_back(root->val);if(root->left) helper(root->left, res);if(root->right) helper(root->right, res);}};使⽤辅助栈迭代实现：算法为：先把根节点push到辅助栈中，然后循环检测栈是否为空，若不空，则取出栈顶元素，保存值到vector中，之后由于需要想访问左⼦节点，所以我们在将根节点的⼦节点⼊栈时要先经右节点⼊栈，再将左节点⼊栈，这样出栈时就会先判断左⼦节点。
代码如下：class Solution {public:vector<int> preorderTraversal(TreeNode* root) {if(root == NULL) return {};vector<int> res;stack<TreeNode*> st;st.push(root);while(!st.empty()){//将根节点出栈放⼊结果集中TreeNode *t = st.top();st.pop();res.push_back(t->val);//先⼊栈右节点，后左节点if(t->right) st.push(t->right);if(t->left) st.push(t->left);}return res;}};Morris Traversal⽅法具体的详细解释可以参考如下链接：这种解法可以实现O(N)的时间复杂度和O(1)的空间复杂度。
二叉树常用的三种遍历方法
二叉树常用的三种遍历方法二叉树是一种常用的数据结构，它由一个根节点和两个子节点组成，其中左子节点小于根节点，右子节点大于根节点。
遍历二叉树是对所有节点进行访问的过程，常用的三种遍历方法是前序遍历、中序遍历和后序遍历。
下面将详细介绍这三种方法的实现步骤。
一、前序遍历前序遍历是指先访问根节点，然后按照左子树、右子树的顺序依次访问每个节点。
具体实现步骤如下：1. 如果当前节点为空，则返回。
2. 访问当前节点。
3. 递归进入左子树。
4. 递归进入右子树。
代码实现：void preorderTraversal(TreeNode* root) {if (root == NULL) return;cout << root->val << " ";preorderTraversal(root->left);preorderTraversal(root->right);}二、中序遍历中序遍历是指先访问左子树，然后访问根节点，最后访问右子树。
具体实现步骤如下：1. 如果当前节点为空，则返回。
2. 递归进入左子树。
3. 访问当前节点。
4. 递归进入右子树。
代码实现：void inorderTraversal(TreeNode* root) {if (root == NULL) return;inorderTraversal(root->left);cout << root->val << " ";inorderTraversal(root->right);}三、后序遍历后序遍历是指先访问左子树，然后访问右子树，最后访问根节点。
具体实现步骤如下：1. 如果当前节点为空，则返回。
2. 递归进入左子树。
3. 递归进入右子树。
4. 访问当前节点。
代码实现：void postorderTraversal(TreeNode* root) {if (root == NULL) return;postorderTraversal(root->left);postorderTraversal(root->right);cout << root->val << " ";}总结：以上就是二叉树常用的三种遍历方法的详细介绍和实现步骤。
实验六二叉树实验报告
实验四二叉树的操作题目：对于给定的一二叉树，实现各种约定的遍历。
一、实验目的：（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. 进入演示程序后的显示主界面：请输入二叉树中的元素；先序、中序和后序遍历分别输出结果。
C语言实现创建二叉树，先序遍历、中序遍历、后序遍历输出
C语⾔实现创建⼆叉树，先序遍历、中序遍历、后序遍历输出# include <stdio.h># include <stdlib.h># include <string.h># include <iostream># define OK 0;# define ERROR -1;typedef int TElemType;typedef char DataType;typedef int Status;typedef struct BiNode {DataType data;//存⾃定义类型的值struct BiNode *lchild, *rchild;//左右⼩孩指针}BiNode,*BiTree;void CreatBiNode(BiNode **Node)//此处应注意传递的参数（⼆重指针）{char data;scanf_s("%c", &data);*Node = (BiTree)malloc(sizeof(BiNode));if (data == '#'){*Node = NULL;}else if ((data != '#') && (*Node)){(*Node)->data = data;(*Node)->lchild = NULL;(*Node)->rchild = NULL;CreatBiNode(&(*Node)->lchild);CreatBiNode(&(*Node)->rchild);}}Status PreOrderTraverse(BiTree T) {if (T == NULL) {return OK;}else {printf("%c", T->data);PreOrderTraverse(T->lchild);PreOrderTraverse(T->rchild);}}Status InOrderTraverse(BiTree T) {if (T == NULL) {return OK;}else {InOrderTraverse(T->lchild);printf("%c", T->data);InOrderTraverse(T->rchild);}}Status PostOrderTraverse(BiTree T) {if (T == NULL) {return OK;}else {PostOrderTraverse(T->lchild);PostOrderTraverse(T->rchild);printf("%c", T->data);}}int main(){printf("先序输⼊⼆叉树(空结点⽤'#'表⽰):");BiTree T=NULL;CreatBiNode(&T);printf("先序遍历⼆叉树：");PreOrderTraverse(T);printf("\n中序遍历⼆叉树：");InOrderTraverse(T);printf("\n后序遍历⼆叉树：");PostOrderTraverse(T);system("pause");return 0;}解决思想：⼩⽣⽤的是递归创建⼆叉树，递归遍历⼆叉树，因为使⽤递归会⽐较简洁。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
ｐrｉntf（"二叉树的先序序列：\n")；
prｉntf("递归：\t")；
PreOrderTｒaｖeｒse(T);
ﻩprｉｎtf(＂\n")；
pｒｉntf(＂非递归:");
ﻩPreOrｄerＴravｅrse2(T);
ﻩpｒｉntf("\n＂）；
ﻩｐrintf("二叉树的中序序列:\n")；
ｖoiｄＩnOrｄerTraveｒse２(ＢiTree T）;ﻩ/＊二叉树的中序遍历的非递归函数声明*/
ｖoidPostOrｄerTraｖeｒｓe2(ＢiTｒｅeＴ）;/*二叉树的后序遍历的非递归函数声明＊/
vｏid mａin()
{
BiTｒeｅT,root；
IniｔBitTｒee(&T);
ﻩprintｆ("根据输入二叉叉树并输出三种遍历结果
———————————————————————————————— 作者:
———————————————————————————————— 日期:
ﻩ
实验报告
课程名称数据结构
实验项目实验三-－创建一个二叉树并输出三种遍历结果
系 别＿__ ＿计算机学院 ＿ ______
专 业_＿_ _＿_
班级/学号___＿＿__＿___
学生姓名 _＿__＿__＿_
实验日期＿
成 绩___＿＿___＿_____＿__＿__＿__
指导教师
实验题目:实验三－--－-－创建一个二叉树并输出三种遍历结果
一、实验目的
1)掌握二叉树存储结构;
2)掌握并实现二叉树遍历的递归算法和非递归算法；
3)理解树及森林对二叉树的转换;
ﻩpｒinｔf（"\n");
ﻩｐｒinｔf（"非递归：");
ﻩPosｔOrdeｒTｒavｅｒsｅ２（T);
ﻩｐrintf(＂\ｎ");
｝
vｏid InitＢitＴree(ＢiTｒeｅ*Ｔ)
{
*T=NUＬL；
}
void CreatｅBitＴｒｅe(ＢiTree *T)
/*递归创建二叉树＊/
｛
DataTypｅch；
ｐrintf("递归:\t");
IｎOrdeｒTraverse(Ｔ）;
ﻩｐrｉntf（＂\ｎ");
prｉntf("非递归：")；
ﻩInOｒdeｒTravｅrse2(T）；
ﻩｐrintf（"\n");
ﻩpriｎｔｆ(＂二叉树的后序序列:\n");
ﻩprｉntf("递归:\t"）;
PoｓｔＯｒderTraverse(T);
（2）然后以递归的先序遍历方法创建二叉树，函数为CreatｅTrｅｅ(），在输入字符时要注意，当节点的左孩子或者右孩子为空的时候，应当输入一个特殊的字符（本算法为“#”),表示左孩子或者右孩子为空。
（3）下一步,创建利用递归方法先序遍历二叉树的函数，函数为PreＯrderTree(),创建非递归方法中序遍历二叉树的函数,函数为IｎOｒderＴree（)，中序遍历过程是:从二叉树的根节点开始，沿左子树向下搜索,在搜索过程将所遇到的节点进栈；左子树遍历完毕后,从栈顶退出栈中的节点并访问；然后再用上述过程遍历右子树，依次类推,指导整棵二叉树全部访问完毕。创建递归方法后序遍历二叉树的函数,函数为LaOrdｅrＴｒee(）。
(提示:该部分主要是利用C、Ｃ＋＋等完成数据结构定义、设计算法实现各种操作,可以用列表分步形式的自然语言描述，也可以利用流程图等描述)
4)编码
#include<ｓtdiｏ.ｈ>
#inｃlude＜malloc.ｈ>
＃incluｄe<stdliｂ.h＞
tyｐｅｄef cｈar DataＴype；
＃ｄefineＭaxSiｚe１０0
2)本实验用到的理论知识
遍历二叉树,递归和非递归的方法
（提示：总结本实验用到的理论知识，实现理论与实践相结合。总结尽量简明扼要，并与本次实验密切相关,要求结合自己的题目并阐述自己的理解和想法)
3)具体算法设计
（1）首先，定义二叉树的存储结构为二叉链表存储，每个元素的数据类型Elemtyｐｅ,定义一棵二叉树,只需定义其根指针。
4)理解二叉树的应用—哈夫曼编码及ＷPＬ计算。
二、实验内容
1)以广义表或遍历序列形式创建一个二叉树，存储结构自选；
2)输出先序、中序、后序遍历序列；
3)二选一应用题:1）树和森林向二叉树转换；2)哈夫曼编码的应用问题。（应用型题目可替换上述前两项实验内容）
三、设计与编码
1)程序结构基本设计框架
（提示：请根据所选定题目，描述程序的基本框架,可以用流程图、界面描述图、框图等来表示）
CreateBitTｒee(&((*T)->rcｈild)）; ﻩﻩ/*构造右子树*/
}
}
voｉdPｒeOrderTrａveｒse(BiTree T)
/＊先序遍历二叉树的递归实现＊/
{
ｉf(T)ﻩﻩﻩﻩ/*如果二叉树不为空*/
{
ｐｒiｎtf("%2c＂,T->dａta）;ﻩ/＊访问根结点*/
PrｅOrderＴraverse(T-＞lcｈilｄ）;ﻩ/*先序遍历左子树＊/
ｖoｉｄＰｒeOｒｄeｒTravｅrｓｅ(BiTree T）；/*二叉树的先序遍历的递归函数声明*/
ｖoidＩｎOrderＴｒavｅrse（BiTreｅＴ）;/＊二叉树的中序遍历的递归函数声明*／
ｖoid PosｔOrdeｒＴrａverse（BｉTrｅeＴ）;/＊二叉树的后序遍历的递归函数声明＊/
ｖoidPrｅOrdｅrTraverse2(ＢｉＴreｅT);/＊二叉树的先序遍历的非递归函数声明＊/
tｙpeｄef structNode
｛
DaｔａTypeｄata;
ﻩstrｕctＮoｄe*lｃhilｄ;
structNoｄｅ*rｃhild;
｝
*ＢiTｒeｅ,BitＮode;
ｖoiｄIniｔBｉtTrｅe(BiＴｒeｅ*Ｔ); /*树的初始化*/
ｖoｉd CrｅaｔｅBitTreｅ(BｉTrｅe*Ｔ);/*按照先序输入字符序列递归创建二叉树*/
sｃanf（＂%ｃ"，&ｃh);
iｆ(ｃh=='#')
*T=ＮULＬ；
elｓe
{
*Ｔ＝(BｉＴｒｅe)ｍalloc(ｓizeof(BｉtNoｄe））;ﻩ/*生成根结点＊／
if(!(*Ｔ))
eｘiｔ(-１);
(*T)－>data=ch；
CreateBitＴree（&(（＊T)－>lｃｈild))；ﻩ/＊构造左子树*／