数据结构：树形结构完整代码,各种遍历方法,直接能跑
前端处理树形结构数据的方法
前端处理树形结构数据的方法标题：前端处理树形结构数据的方法在前端开发中，我们常常会遇到需要处理树形结构数据的情况。
树形结构数据是一种非常常见的数据结构，例如文件目录、组织架构、菜单导航等都可以抽象为树形结构。
那么，在前端如何有效地处理这种数据呢？下面将介绍几种常用的方法。
一、递归方法递归是处理树形结构数据最直接的方法。
通过定义一个函数，该函数接受一个节点作为参数，然后遍历这个节点的所有子节点，对每个子节点调用自身，直到所有节点都被访问过。
这种方法的优点是逻辑清晰，易于理解，但是当数据量较大时，可能会导致栈溢出。
二、广度优先搜索(BFS)广度优先搜索是一种从根节点开始，逐层遍历的算法。
我们可以使用队列来实现BFS，首先将根节点入队，然后每次从队列中取出一个节点，将其子节点依次入队，直到队列为空。
这种方法的优点是可以保证每一层的节点都会按照顺序被访问到，而且不会导致栈溢出。
三、深度优先搜索(DFS)深度优先搜索是一种沿着某条路径尽可能深地搜索的算法。
我们可以使用栈来实现DFS，首先将根节点入栈，然后每次从栈顶取出一个节点，将其子节点依次入栈，直到栈为空。
这种方法的优点是可以保证一条路径上的所有节点都会按照顺序被访问到。
四、使用库除了自己实现上述算法外，我们还可以使用一些现成的库来处理树形结构数据，如lodash的_.tree方法，或是JavaScript标准库中的Array.from方法等。
这些库通常提供了丰富的API和优化过的算法，可以大大提高我们的开发效率。
总结：处理树形结构数据是前端开发中的常见任务，不同的方法有其适用的场景和优缺点。
在实际开发中，我们需要根据具体的需求和数据规模选择合适的方法。
同时，也可以利用现成的库来简化开发过程，提高代码质量。
JS树结构数据的遍历
JS树结构数据的遍历树结构是一种常见的数据结构，它由若干节点组成，节点之间存在一对多的关系。
在前端开发中，经常需要遍历树结构的数据来进行处理操作。
本文将介绍几种常用的树结构数据的遍历算法。
一、深度优先遍历（DFS）深度优先遍历是一种递归的遍历算法，其核心思想是先遍历子节点，再遍历父节点。
在JavaScript中，可以使用递归函数来实现深度优先遍历。
以下是一个简单的树结构数据的遍历例子：```javascriptfunction dfs(node)console.log(node.value);if (node.children)for (let child of node.children)dfs(child);}}```在上述例子中，dfs函数用来深度优先遍历树结构数据。
它首先打印当前节点的值，然后递归调用dfs函数遍历子节点。
二、广度优先遍历（BFS）广度优先遍历是一种按层次顺序遍历节点的算法，其核心思想是先遍历同一层的节点，再遍历下一层的节点。
在JavaScript中，可以使用队列来实现广度优先遍历。
以下是一个简单的树结构数据的遍历例子：```javascriptfunction bfs(root)let queue = [root];while (queue.length > 0)let node = queue.shift(;console.log(node.value);if (node.children)for (let child of node.children)queue.push(child);}}}```在上述例子中，bfs函数用来广度优先遍历树结构数据。
它使用一个队列来保存待遍历的节点，初始时将根节点加入队列，然后循环进行以下操作：从队列中取出一个节点，打印该节点的值，将该节点的子节点加入队列。
三、前序遍历、中序遍历和后序遍历（二叉树）在二叉树中，除了深度优先遍历和广度优先遍历外，还常用以下三种特殊的遍历方式：1. 前序遍历（pre-order）：先访问根节点，再依次访问左子树和右子树。
树的遍历的三种方法
树的遍历的三种方法树是一种非线性的数据结构，由节点和边组成的集合，节点代表实体，边代表节点之间的连接关系。
在树的操作中，遍历是一种重要的基本操作，它用于按照一定的顺序访问树中的所有节点。
树的遍历方法主要有三种：前序遍历、中序遍历和后序遍历。
下面将对这三种遍历方法进行详细的介绍。
一、前序遍历（Preorder Traversal）前序遍历是从根节点开始，按照根节点-左子树-右子树的顺序访问所有节点。
具体步骤如下：1.若树为空，则直接返回。
2.访问当前节点。
3.递归地前序遍历左子树。
4.递归地前序遍历右子树。
前序遍历的代码示例：```pythondef preorder(root):if root is None:returnprint(root.val)preorder(root.left)preorder(root.right)```二、中序遍历（Inorder Traversal）中序遍历是从左子树开始，按照左子树-根节点-右子树的顺序访问所有节点。
具体步骤如下：1.若树为空，则直接返回。
2.递归地中序遍历左子树。
3.访问当前节点。
4.递归地中序遍历右子树。
中序遍历的代码示例：```pythondef inorder(root):if root is None:returninorder(root.left)print(root.val)inorder(root.right)```三、后序遍历（Postorder Traversal）后序遍历是从左子树开始，按照左子树-右子树-根节点的顺序访问所有节点。
具体步骤如下：1.若树为空，则直接返回。
2.递归地后序遍历左子树。
3.递归地后序遍历右子树。
4.访问当前节点。
后序遍历的代码示例：```pythondef postorder(root):if root is None:returnpostorder(root.left)postorder(root.right)print(root.val)```以上是树的三种遍历方法的详细介绍及示例代码。
树的表示法 字典解释
树的表示法字典解释
树是一种数据结构，它由若干个节点组成，这些节点通过边相连。
树的表示法有多种，其中比较常见的包括以下几种：
1. 儿子-兄弟表示法（孩子兄弟表示法），这种表示法通过每
个节点的指针来表示树的结构。
每个节点有两个指针，一个指向它
的第一个孩子节点，另一个指向它的下一个兄弟节点。
这种表示法
适合于一般的树，但不适合于二叉树。
2. 层次遍历表示法，这种表示法是按照树的层次结构来表示的，通常使用数组或者队列来表示。
从根节点开始，按照层次顺序依次
存储每个节点的数值，空节点用特定的符号表示。
这种表示法适合
于完全二叉树。
3. 括号表示法，这种表示法是通过括号和逗号来表示树的结构。
具体来说，可以使用前序遍历的方式，通过括号表示节点的嵌套关系。
例如，树 (A(B(C))(D)) 可以表示为 A(B(C))(D)。
树的表示法可以根据具体的应用场景和需要选择合适的方式。
每种表示法都有其适用的范围和特点，需要根据实际情况进行选择。
希望这些信息能够帮助你更好地理解树的表示法。
树形结构的例子
树形结构的例子树形结构是一种常见的数据结构，它由节点和边组成，用于表示具有层次关系的数据。
以下是一些树形结构的例子：1. 文件系统树：文件系统树是计算机文件系统的一种组织形式。
它以根目录为起点，每个目录都可以包含其他目录和文件。
通过文件系统树，用户可以方便地浏览和管理文件。
2. HTML文档树：HTML文档树用于表示网页的结构和内容。
它由一个根节点开始，每个节点都可以包含其他节点，形成层次关系。
通过HTML文档树，浏览器可以解析和渲染网页。
3. 组织机构树：组织机构树用于表示企业或组织的组织结构。
根节点代表整个组织，每个节点代表一个部门或岗位，节点之间的边表示上下级关系。
通过组织机构树，可以清晰地了解企业的组织架构。
4. 家谱树：家谱树用于表示家族的家族关系。
根节点代表始祖，每个节点代表一个人，节点之间的边表示父子关系。
通过家谱树，可以追溯和查找家族的成员和血缘关系。
5. 类型继承树：在面向对象编程中，类型继承树用于表示类的继承关系。
根节点代表基类，每个节点代表一个派生类，节点之间的边表示继承关系。
通过类型继承树，可以清晰地了解类的继承结构。
6. 商品分类树：在电商网站中，商品分类树用于表示商品的分类关系。
根节点代表整个商品分类体系，每个节点代表一个商品分类，节点之间的边表示上下级分类关系。
通过商品分类树，用户可以方便地浏览和搜索商品。
7. 语言家族树：在语言学中，语言家族树用于表示不同语言之间的关系。
根节点代表原始语言，每个节点代表一种语言，节点之间的边表示语言演化和分支关系。
通过语言家族树，可以研究和比较不同语言的历史和特点。
8. 系统调用树：在操作系统中，系统调用树用于表示不同系统调用的关系和层次。
根节点代表操作系统内核，每个节点代表一个系统调用，节点之间的边表示调用关系。
通过系统调用树，可以了解和使用不同系统调用的功能和接口。
9. 目录结构树：目录结构树用于表示文件或文件夹的组织关系。
根节点代表根目录，每个节点代表一个文件或文件夹，节点之间的边表示包含关系。
数据结构入门-树的遍历以及二叉树的创建
数据结构⼊门-树的遍历以及⼆叉树的创建树定义：1. 有且只有⼀个称为根的节点2. 有若⼲个互不相交的⼦树，这些⼦树本⾝也是⼀个树通俗的讲：1. 树是有结点和边组成，2. 每个结点只有⼀个⽗结点，但可以有多个⼦节点3. 但有⼀个节点例外，该节点没有⽗结点，称为根节点⼀、专业术语结点、⽗结点、⼦结点、根结点深度：从根节点到最底层结点的层数称为深度，根节点第⼀层叶⼦结点：没有⼦结点的结点⾮终端节点：实际上是⾮叶⼦结点度：⼦结点的个数成为度⼆、树的分类⼀般树：任意⼀个结点的⼦结点的个数都不受限制⼆叉树：任意⼀个结点的⼦结点个数最多是两个，且⼦结点的位置不可更改⼆叉数分类：1. ⼀般⼆叉数2. 满⼆叉树：在不增加树层数的前提下，⽆法再多添加⼀个结点的⼆叉树3. 完全⼆叉树：如果只是删除了满⼆叉树最底层最右边的连续若⼲个结点，这样形成的⼆叉树就是完全⼆叉树森林：n个互不相交的树的集合三、树的存储⼆叉树存储连续存储(完全⼆叉树)优点：查找某个结点的⽗结点和⼦结点(也包括判断有没有⼦结点)速度很快缺点：耗⽤内存空间过⼤链式存储⼀般树存储1. 双亲表⽰法：求⽗结点⽅便2. 孩⼦表⽰法：求⼦结点⽅便3. 双亲孩⼦表⽰法：求⽗结点和⼦结点都很⽅便4. ⼆叉树表⽰法：把⼀个⼀般树转化成⼀个⼆叉树来存储，具体转换⽅法：设法保证任意⼀个结点的左指针域指向它的第⼀个孩⼦，右指针域指向它的兄弟，只要能满⾜此条件，就可以把⼀个⼀般树转化为⼆叉树⼀个普通树转换成的⼆叉树⼀定没有右⼦树森林的存储先把森林转化为⼆叉树，再存储⼆叉树四、树的遍历先序遍历：根左右先访问根结点，再先序访问左⼦树，再先序访问右⼦树中序遍历：左根右中序遍历左⼦树，再访问根结点，再中序遍历右⼦树后续遍历：左右根后续遍历左⼦树，后续遍历右⼦树，再访问根节点五、已知两种遍历求原始⼆叉树给定了⼆叉树的任何⼀种遍历序列，都⽆法唯⼀确定相应的⼆叉树，但是如果知道了⼆叉树的中序遍历序列和任意的另⼀种遍历序列，就可以唯⼀地确定⼆叉树已知先序和中序求后序先序：ABCDEFGH中序：BDCEAFHG求后序：这个⾃⼰画个图体会⼀下就可以了，⾮常简单，这⾥简单记录⼀下1. ⾸先根据先序确定根，上⾯的A就是根2. 中序确定左右，A左边就是左树(BDCE)，A右边就是右树(FHG)3. 再根据先序，A左下⾯就是B，然后根据中序，B左边没有，右边是DCE4. 再根据先序，B右下是C，根据中序，c左下边是D，右下边是E，所以整个左树就确定了5. 右树，根据先序，A右下是F，然后根据中序，F的左下没有，右下是HG，6. 根据先序，F右下为G，然后根据中序，H在G的左边，所以G的左下边是H再来⼀个例⼦，和上⾯的思路是⼀样的，这⾥就不详细的写了先序：ABDGHCEFI中序：GDHBAECIF已知中序和后序求先序中序：BDCEAFHG后序：DECBHGFA这个和上⾯的思路是⼀样的，只不过是反过来找，后序找根，中序找左右树简单应⽤树是数据库中数据组织⼀种重要形式操作系统⼦⽗进程的关系本⾝就是⼀棵树⾯向对象语⾔中类的继承关系哈夫曼树六、⼆叉树的创建#include <stdio.h>#include <stdlib.h>typedef struct Node{char data;struct Node * lchild;struct Node * rchild;}BTNode;/*⼆叉树建⽴*/void BuildBT(BTNode ** tree){char ch;scanf("%c" , &ch); // 输⼊数据if(ch == '#') // 如果这个节点的数据是#说明这个结点为空*tree = NULL;else{*tree = (BTNode*)malloc(sizeof(BTNode));//申请⼀个结点的内存 (*tree)->data = ch; // 将数据写⼊到结点⾥⾯BuildBT(&(*tree)->lchild); // 递归建⽴左⼦树BuildBT(&(*tree)->rchild); // 递归建⽴右⼦树}}/*⼆叉树销毁*/void DestroyBT(BTNode *tree) // 传⼊根结点{if(tree != NULL){DestroyBT(tree->lchild);DestroyBT(tree->rchild);free(tree); // 释放内存空间}}/*⼆叉树的先序遍历*/void Preorder(BTNode * node){if(node == NULL)return;else{printf("%c ",node->data );Preorder(node->lchild);Preorder(node->rchild);}}/*⼆叉树的中序遍历*/void Inorder(BTNode * node){if(node == NULL)return;else{Inorder(node->lchild);printf("%c ",node->data );Inorder(node->rchild);}}/*⼆叉树的后序遍历*/void Postorder(BTNode * node){if(node == NULL)return;else{Postorder(node->lchild);Postorder(node->rchild);printf("%c ",node->data );}}/*⼆叉树的⾼度树的⾼度 = max(左⼦树⾼度，右⼦树⾼度) +1*/int getHeight(BTNode *node){int Height = 0;if (node == NULL)return 0;else{int L_height = getHeight(node->lchild);int R_height = getHeight(node->rchild);Height = L_height >= R_height ? L_height +1 : R_height +1; }return Height;}int main(int argc, char const *argv[]){BTNode * BTree; // 定义⼀个⼆叉树printf("请输⼊⼀颗⼆叉树先序序列以#表⽰空结点:");BuildBT(&BTree);printf("先序序列：");Preorder(BTree);printf("\n中序序列：");Inorder(BTree);printf("\n后序序列：");Postorder(BTree);printf("\n树的⾼度为：%d" , getHeight(BTree));return 0;}// ABC##DE##F##G##。
数据结构二叉树的基本操作代码
数据结构二叉树的基本操作代码x#include<iostream>using namespace std;//二叉树的结构struct TreeNode{int data;//节点的值TreeNode *left;//指向左子树TreeNode *right;//指向右子树};//插入节点void insert(TreeNode *&tree, int val){if(tree == NULL){tree = new TreeNode;tree->data = val;tree->left = tree->right = NULL;}else if(val<=tree->data)//小于根节点的值则插入到左子树 insert(tree->left, val);else if(val>tree->data)//大于根节点的值则插入到右子树 insert(tree->right,val);}//查找节点TreeNode* find(TreeNode *tree,int val){if (tree == NULL)//树为空，无法查找return NULL;else if (val == tree->data)//值和节点的值相等，返回该节点return tree;else if (val < tree->data)//值小于节点的值，查找左子树 return find(tree->left,val);else if (val > tree->data)//值大于节点的值，查找右子树 return find(tree->right,val);elsereturn NULL;//无法查找}//遍历二叉树//先序遍历void preOrder(TreeNode *tree){if(tree != NULL){cout<< tree->data <<'t'; //先访问根节点preOrder(tree->left); //再遍历左子树 preOrder(tree->right); //最后遍历右子树 }}//中序遍历void inOrder(TreeNode *tree){if(tree != NULL){inOrder(tree->left); //先遍历左子树 cout<< tree->data <<'t'; //再访问根节点inOrder(tree->right); //最后遍历右子树 }}//后序遍历void postOrder(TreeNode *tree){if(tree != NULL){postOrder(tree->left); //先遍历左子树 postOrder(tree->right); //再遍历右子树 cout<< tree->data <<'t'; //最后访问根节点 }}//查找最大值TreeNode* findMax(TreeNode *tree){if(tree == NULL)return NULL;else if(tree->right == NULL)return tree;elsereturn findMax(tree->right);}//查找最小值TreeNode* findMin(TreeNode *tree){if(tree == NULL)return NULL;else if(tree->left == NULL)return tree;elsereturn findMin(tree->left);}//删除节点void remove(TreeNode *&tree, int val){if(tree == NULL)return;else if(val < tree->data)remove(tree->left, val);else if(val > tree->data)remove(tree->right, val);else//找到要删除的节点{if(tree->left != NULL && tree->right != NULL)//左右子树均不为空{TreeNode *temp = tree;TreeNode *max = findMax(tree->left);//查找左子树的最大结点tree->data = max->data;//将最大结点的值替换到要删除的节点remove(temp->left, max->data);//将最大结点删掉}else//只有一边的子节点不为空或者左右节点都为空{TreeNode *temp = tree;if(tree->left == NULL)//如果左节点为空，就将右节点提升 tree = tree->right;else if(tree->right == NULL)//如果右节点为空，就将左节点提升tree = tree->left;delete temp;//删掉要删除的节点}}}int main(){TreeNode *tree = NULL; //声明一个空树int arr[10] = {12, 3, 4, 6, 7, 9, 10, 5, 2, 8};for(int i=0; i<10; i++){insert(tree, arr[i]);//把数组元素插入到树当中}cout<<'先序遍历：';preOrder(tree);cout<<endl;cout<<'中序遍历：';inOrder(tree);cout<<endl;cout<<'后序遍历：';postOrder(tree);cout<<endl;cout<<'查找节点数据：4';TreeNode *findNode = find(tree, 4);if(findNode != NULL)//如果节点存在cout<<'找到了，节点的值是：'<<findNode->data;else//如果节点不存在cout<<'没有找到';cout<<endl;cout<<'查找树的最大值：'<<findMax(tree)->data<<endl; cout<<'查找树的最小值：'<<findMin(tree)->data<<endl; cout<<'删除节点：。
数据结构ppt课件完整版
数据结构分类
根据数据元素之间关系的不同， 数据结构可分为线性结构、树形 结构、图形结构等。
4
数据结构重要性
01
02
03
提高算法效率
合理的数据结构可以大大 提高算法的执行效率，减 少时间和空间复杂度。
33
案例三：最小生成树在通信网络优化中应用
Kruskal算法
基于并查集实现，按照边的权值从小到大依次添加边，直到生成 最小生成树。
Prim算法
从某一顶点开始，每次选择与当前生成树最近的顶点加入，直到 所有顶点都加入生成树。
通信网络优化
最小生成树算法可用于通信网络优化，通过选择最优的通信线路 和节点，降低网络建设和维护成本。
2024/1/28
简化程序设计
数据结构的设计和实现可 以简化程序设计过程，提 高代码的可读性和可维护 性。
解决实际问题
数据结构是解决实际问题 的基础，如排序、查找、 图论等问题都需要依赖于 特定的数据结构。
5
相关术语解析
数据元素
数据元素是数据的基本 单位，通常作为一个整
体进行考虑和处理。
2024/1/28
02
队列的基本操作包括入队（enqueue）、出队（ dequeue）、查看队首和队尾元素等。
03
队列的特点
2024/1/28
04
数据从队尾入队，从队首出队。
05
队列中元素的插入和删除操作分别在两端进行，因此也称 为双端操作。
06
队列中没有明显的头尾标记，通常通过计数器或循环数组 等方式实现。
15
栈和队列应用举例
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include <stdio.h>#include <stdlib.h>#define TElemType inttypedef struct BiTNode {TElemType data;struct BiTNode *lchild, *rchild;} BiTNode, *BiTree;typedef BiTree DataType;typedef struct queuenode{DataType data;struct queuenode *next;} QueueNode;//LINKQUEUE//HEAD POINTER, AND REAR POINTER ARE A V ALIBALE typedef struct {QueueNode *front;QueueNode *rear;} LinkQueue;int InitQueue(LinkQueue *Q);int DestroyQueue(LinkQueue *Q);int QueueEmpty(LinkQueue Q);int EnQueue(LinkQueue *Q, DataType e);DataType DeQueue(LinkQueue *Q);int CreateBiTree(BiTree *T);int PreOrderTraverse(BiTree T, int (*visit)(TElemType e));int PreOrderTraverse2(BiTree T, int (*visit)(TElemType e));int InOrderTraverse(BiTree T, int (*visit)(TElemType e));int InOrderTraverse2(BiTree T, int (*visit)(TElemType e));int PostOrderTraverse(BiTree T, int (*visit)(TElemType e));int PostOrderTraverse2(BiTree T, int (*visit)(TElemType e)); int LevelOrderTraverse(BiTree T, int (*visit)(TElemType e)); int printElem(TElemType e);int InitBiTree(BiTree *T);int DestroyBiTree(BiTree *T);int ClearBiTree(BiTree *T);int BiTreeEmpty(BiTree T);int BiTreeDepth(BiTree T);BiTNode *Parent(BiTree T, BiTNode *e);BiTNode *LeftChild(BiTree T, BiTNode *e);BiTNode *RightChild(BiTree T, BiTNode *e);BiTNode *LeftSibling(BiTree T, BiTNode *e);BiTNode *RightSibling(BiTree T, BiTNode *e);int InsertChild(BiTree T, BiTNode *p, int LR, BiTree C);int DeleteChild(BiTree T, BiTNode *p, int LR);int CountLeaf(BiTree T);int CreateBiTreeByPreInOrder(BiTree *T, int preorder[], int *idx,int inorder[], int low, int high,int length);int main(){BiTree bitree,bitree2;InitBiTree(&bitree);InitBiTree(&bitree2);printf("input tree 1:\n");CreateBiTree2(&bitree);printf("PreOrderTraverse:\n");PreOrderTraverse(bitree, printElem);printf("\n");printf("InOrderTraverse:\n");InOrderTraverse(bitree, printElem);printf("\n");printf("PostOrderTraverse:\n");PostOrderTraverse(bitree, printElem);printf("\n");printf("LevelOrderTraverse:\n");LevelOrderTraverse(bitree, printElem);printf("\n");printf("Depth is %d.\n", BiTreeDepth(bitree));printf("Count leaf is %d.\n", CountLeaf(bitree));DestroyBiTree(&bitree);DestroyBiTree(&bitree2);}int CreateBiTree(BiTree *T){int num;scanf("%d", &num);if (num == 0)*T = NULL;else {*T = malloc(sizeof(BiTNode));if (*T == NULL)return 0;(*T)->data = num;if (!CreateBiTree(&(*T)->lchild)) return 0;if (!CreateBiTree(&(*T)->rchild)) return 0;}return 1;}int PreOrderTraverse(BiTree T, int (*visit)(TElemType e)) {if (T) {//visit rootif (!(*visit)(T->data)) return 0;//visit left treeif (!PreOrderTraverse(T->lchild, visit)) return 0;//visit right treeif (!PreOrderTraverse(T->rchild, visit)) return 0;}return 1;}int PreOrderTraverse2(BiTree T, int (*visit)(TElemType e)) {//visit rootif (!(*visit)(T->data)) return 0;if (T->lchild)//visit left treeif (!PreOrderTraverse(T->lchild, visit)) return 0;if (T->rchild)//visit right treeif (!PreOrderTraverse(T->rchild, visit)) return 0;return 1;int InOrderTraverse(BiTree T, int (*visit)(TElemType e)) {if (T) {//visit left treeif (!InOrderTraverse(T->lchild, visit)) return 0;//visit rootif (!(*visit)(T->data)) return 0;//visit right treeif (!InOrderTraverse(T->rchild, visit)) return 0;}return 1;}int PostOrderTraverse(BiTree T, int (*visit)(TElemType e)) {if (T) {//visit left treeif (!PostOrderTraverse(T->lchild, visit)) return 0;//visit right treeif (!PostOrderTraverse(T->rchild, visit)) return 0;//visit rootif (!(*visit)(T->data)) return 0;}return 1;}int LevelOrderTraverse(BiTree T, int (*visit)(TElemType e)) {//defineLinkQueue queue;//initInitQueue(&queue);//root enqueueEnQueue(&queue, T);while(!QueueEmpty(queue)) {//dequeueBiTree node = DeQueue(&queue);if (node) {//visitif (!(*visit)(node->data)) return 0;//left child enqueueEnQueue(&queue, node->lchild);//right child enqueueEnQueue(&queue, node->rchild);}}DestroyQueue(&queue);return 1;}int printElem(TElemType e){printf("%d ", e);return 1;}int InitBiTree(BiTree *T){*T = NULL;return 1;}int DestroyBiTree(BiTree *T){if (*T) {//destroy left treeDestroyBiTree(&(*T)->lchild);//destroy right treeDestroyBiTree(&(*T)->rchild);//destroy rootfree(*T); *T = NULL;}return 1;}int ClearBiTree(BiTree *T){return DestroyBiTree(T);}int BiTreeEmpty(BiTree T){if (T)return 0;elsereturn 1;}int BiTreeDepth(BiTree T){if (!T)return 0;int ldepth = BiTreeDepth(T->lchild);int rdepth = BiTreeDepth(T->rchild);return (ldepth > rdepth ? ldepth : rdepth) + 1;}BiTNode *Parent(BiTree T, BiTNode *e){if (e == T) return NULL;//defineLinkQueue queue;//initInitQueue(&queue);//root enqueueEnQueue(&queue, T);BiTNode *node = NULL;while(!QueueEmpty(queue)) {//dequeuenode = DeQueue(&queue);if (node) {//compareif (e == node->lchild || e == node->rchild)break;//left child enqueueEnQueue(&queue, node->lchild);//right child enqueueEnQueue(&queue, node->rchild);}}DestroyQueue(&queue);return node;}BiTNode *LeftChild(BiTree T, BiTNode *e) {/* //defineLinkQueue queue;//initInitQueue(&queue);//root enqueueEnQueue(&queue, T);BiTNode *node = NULL;while(!QueueEmpty(queue)) {//dequeuenode = DeQueue(&queue);if (node) {//compareif (e == node)break;//left child enqueueEnQueue(&queue, node->lchild);//right child enqueueEnQueue(&queue, node->rchild);}}DestroyQueue(&queue);*/return e->lchild;}BiTNode *RightChild(BiTree T, BiTNode *e) {/* //defineLinkQueue queue;//initInitQueue(&queue);//root enqueueEnQueue(&queue, T);BiTNode *node = NULL;while(!QueueEmpty(queue)) {//dequeuenode = DeQueue(&queue);if (node) {//compareif (e == node)break;//left child enqueueEnQueue(&queue, node->lchild);//right child enqueueEnQueue(&queue, node->rchild);}}DestroyQueue(&queue);*/return e->rchild;}BiTNode *LeftSibling(BiTree T, BiTNode *e){BiTNode *parent, *lchild;if ((parent = Parent(T, e)) == NULL) return NULL;lchild = LeftChild(T, parent);if (lchild == e) return NULL;else return lchild;}BiTNode *RightSibling(BiTree T, BiTNode *e){BiTNode *parent, *rchild;if ((parent = Parent(T, e)) == NULL) return NULL;rchild = RightChild(T, parent);if (rchild == e) return NULL;else return rchild;}int InsertChild(BiTree T, BiTNode *p, int LR, BiTree C) {if (LR == 0) {C->rchild = p->lchild;p->lchild = C;} else {C->rchild = p->rchild;p->rchild = C;}return 1;}int DeleteChild(BiTree T, BiTNode *p, int LR){if (LR == 0)if (!DestroyBiTree(&p->lchild)) return 0;elseif (!DestroyBiTree(&p->rchild)) return 0;return 1;}int InitQueue(LinkQueue *Q){Q->front = Q->rear = malloc(sizeof(QueueNode));Q->front->next = NULL;}int DestroyQueue(LinkQueue *Q){QueueNode *p = Q->front, *q;do {q = p->next;free(p);p = q;} while (p!=NULL);Q->front = NULL;Q->rear = NULL;}int QueueEmpty(LinkQueue Q){return Q.front == Q.rear;}int EnQueue(LinkQueue *Q, DataType e){QueueNode *temp = malloc(sizeof(QueueNode));if (!temp) {printf("Memory is out! Cannot malloc.\n");return 0;}temp->data = e;temp->next = NULL;Q->rear->next = temp;Q->rear = temp;return 1;}DataType DeQueue(LinkQueue *Q){DataType ret = Q->front->next->data;QueueNode *p = Q->front->next;Q->front->next = Q->front->next->next;free(p);if (Q->front->next == NULL) Q->rear = Q->front;return ret;}int CountLeaf(BiTree T){if (T == NULL) return 0;if (T->lchild == NULL && T->rchild == NULL) return 1;return CountLeaf(T->lchild) + CountLeaf(T->rchild);}int CreateBiTree2(BiTree *T){int num, inorder[100], preorder[100], i = 0;printf("please input preorder:\n");while(scanf("%d", &num) != EOF) {preorder[i++] = num;}i = 0;printf("please input inorder:\n");while(scanf("%d", &num) != EOF) {inorder[i++] = num;}int index = -1;CreateBiTreeByPreInOrder(T, preorder, &index, inorder, 0, i-1, i);return 1;}int CreateBiTreeByPreInOrder(BiTree *T, int preorder[], int *idx,int inorder[], int low, int high, int length){(*idx)++;if (*idx >= length) {*T = NULL; return 1;}int i;for(i=low;i<=high;i++)if (inorder[i] == preorder[*idx]) break;if (i > high) {(*idx)--; *T = NULL; return 1;}*T = malloc(sizeof(BiTNode));if (*T == NULL)return 0;(*T)->data = preorder[*idx];if (!CreateBiTreeByPreInOrder(&(*T)->lchild, preorder, idx, inorder, low, i-1, length)) return 0;if (!CreateBiTreeByPreInOrder(&(*T)->rchild, preorder, idx, inorder, i+1, high, length)) return 0;return 1;}。