二叉树在C语言中的实现与应用详解
数据结构c语言课设-二叉树排序
题目:二叉排序树的实现1 内容和要求1）编程实现二叉排序树，包括生成、插入，删除；2）对二叉排序树进展先根、中根、和后根非递归遍历；3）每次对树的修改操作和遍历操作的显示结果都需要在屏幕上用树的形状表示出来。
4）分别用二叉排序树和数组去存储一个班(50 人以上)的成员信息(至少包括学号、姓名、成绩3 项),比照查找效率，并说明在什么情况下二叉排序树效率高,为什么?2 解决方案和关键代码2.1 解决方案：先实现二叉排序树的生成、插入、删除，编写DisplayBST函数把遍历结果用树的形状表示出来。
前中后根遍历需要用到栈的数据构造，分模块编写栈与遍历代码。
要求比照二叉排序树和数组的查找效率，首先建立一个数组存储一个班的成员信息，分别用二叉树和数组查找，利用clock〔〕函数记录查找时间来比照查找效率。
2.2关键代码树的根本构造定义及根本函数typedef struct{KeyType key;} ElemType;typedef struct BiTNode//定义链表{ElemType data;struct BiTNode *lchild, *rchild;}BiTNode, *BiTree, *SElemType;//销毁树int DestroyBiTree(BiTree &T){if (T != NULL)free(T);return 0;}//清空树int ClearBiTree(BiTree &T){if (T != NULL){T->lchild = NULL;T->rchild = NULL;T = NULL;}return 0;}//查找关键字,指针p返回int SearchBST(BiTree T, KeyType key, BiTree f, BiTree &p) {if (!T){p = f;return FALSE;}else if EQ(key, T->data.key){p = T;return TRUE;}else if LT(key, T->data.key)return SearchBST(T->lchild, key, T, p);elsereturn SearchBST(T->rchild, key, T, p);}二叉树的生成、插入，删除生成void CreateBST(BiTree &BT, BiTree p){int i;ElemType k;printf("请输入元素值以创立排序二叉树:\n");scanf_s("%d", &k.key);for (i = 0; k.key != NULL; i++){//判断是否重复if (!SearchBST(BT, k.key, NULL, p)){InsertBST(BT, k);scanf_s("%d", &k.key);}else{printf("输入数据重复！\n");return;}}}插入int InsertBST(BiTree &T, ElemType e){BiTree s, p;if (!SearchBST(T, e.key, NULL, p)){s = (BiTree)malloc(sizeof(BiTNode));s->data = e;s->lchild = s->rchild = NULL;if (!p)T = s;else if LT(e.key, p->data.key)p->lchild = s;elsep->rchild = s;return TRUE;}else return FALSE;}删除//某个节点元素的删除int DeleteEle(BiTree &p){BiTree q, s;if (!p->rchild) //右子树为空{q = p;p = p->lchild;free(q);}else if (!p->lchild) //左子树为空{q = p;p = p->rchild;free(q);}else{q = p;s = p->lchild;while (s->rchild){q = s;s = s->rchild;}p->data = s->data;if (q != p)q->rchild = s->lchild;elseq->lchild = s->lchild;delete s;}return TRUE;}//整棵树的删除int DeleteBST(BiTree &T, KeyType key) //实现二叉排序树的删除操作{if (!T){return FALSE;}else{if (EQ(key, T->data.key)) //是否相等return DeleteEle(T);else if (LT(key, T->data.key)) //是否小于return DeleteBST(T->lchild, key);elsereturn DeleteBST(T->rchild, key);}return 0;}二叉树的前中后根遍历栈的定义typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;int InitStack(SqStack &S) //构造空栈{S.base = (SElemType*)malloc(STACK_INIT_SIZE *sizeof(SElemType));if (!S.base) exit(OVERFLOW);S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;}//InitStackint Push(SqStack &S, SElemType e) //插入元素e为新栈顶{if (S.top - S.base >= S.stacksize){S.base = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT)*sizeof(SElemType));if (!S.base) exit(OVERFLOW);S.top = S.base + S.stacksize;S.stacksize += STACKINCREMENT;}*S.top++ = e;return OK;}//Pushint Pop(SqStack &S, SElemType &e) //删除栈顶,应用e返回其值{if (S.top == S.base) return ERROR;e = *--S.top;return OK;}//Popint StackEmpty(SqStack S) //判断是否为空栈{if (S.base == S.top) return TRUE;return FALSE;}先根遍历int PreOrderTraverse(BiTree T, int(*Visit)(ElemType e)) {SqStack S;BiTree p;InitStack(S);p = T;while (p || !StackEmpty(S)){if (p){Push(S, p);if (!Visit(p->data)) return ERROR;p = p->lchild;}else{Pop(S, p);p = p->rchild;}}return OK;}中根遍历int InOrderTraverse(BiTree T, int(*Visit)(ElemType e)) {SqStack S;BiTree p;InitStack(S);p = T;while (p || !StackEmpty(S)){if (p){Push(S, p);p = p->lchild;}else{Pop(S, p);if (!Visit(p->data)) return ERROR;p = p->rchild;}}return OK;}后根遍历int PostOrderTraverse(BiTree T, int(*Visit)(ElemType e)) {SqStack S, SS;BiTree p;InitStack(S);InitStack(SS);p = T;while (p || !StackEmpty(S)){if (p){Push(S, p);Push(SS, p);p = p->rchild;}else{if (!StackEmpty(S)){Pop(S, p);p = p->lchild;}}}while (!StackEmpty(SS)){Pop(SS, p);if (!Visit(p->data)) return ERROR;}return OK;}利用数组存储一个班学生信息ElemType a[] = { 51, "陈继真", 88,82, "黄景元", 89,53, "贾成", 88,44, "呼颜", 90,25, "鲁修德", 88,56, "须成", 88,47, "孙祥", 87, 38, "柏有患", 89, 9, " 革高", 89, 10, "考鬲", 87, 31, "李燧", 86, 12, "夏祥", 89, 53, "余惠", 84, 4, "鲁芝", 90, 75, "黄丙庆", 88, 16, "李应", 89, 87, "杨志", 86, 18, "李逵", 89, 9, "阮小五", 85, 20, "史进", 88, 21, "秦明", 88, 82, "杨雄", 89, 23, "刘唐", 85, 64, "武松", 88, 25, "李俊", 88, 86, "卢俊义", 88, 27, "华荣", 87, 28, "杨胜", 88, 29, "林冲", 89, 70, "李跃", 85, 31, "蓝虎", 90, 32, "宋禄", 84, 73, "鲁智深", 89, 34, "关斌", 90, 55, "龚成", 87, 36, "黄乌", 87, 57, "孔道灵", 87, 38, "张焕", 84, 59, "李信", 88, 30, "徐山", 83, 41, "秦祥", 85, 42, "葛公", 85, 23, "武衍公", 87, 94, "范斌", 83, 45, "黄乌", 60, 67, "叶景昌", 99, 7, "焦龙", 89, 78, "星姚烨", 85, 49, "孙吉", 90, 60, "陈梦庚", 95,};数组查询函数void ArraySearch(ElemType a[], int key, int length){int i;for (i = 0; i <= length; i++){if (key == a[i].key){cout << "学号：" << a[i].key << " 姓名：" << a[i].name << " 成绩：" << a[i].grade << endl;break;}}}二叉树查询函数上文二叉树根本函数中的SearchBST()即为二叉树查询函数。
二叉树中和为某一值的路径c语言
以下是一个使用C语言实现二叉树中和为某一值的路径的示例代码：```c#include <stdio.h>#include <stdlib.h>// 定义二叉树结点结构体struct TreeNode {int val;struct TreeNode *left;struct TreeNode *right;};// 中序遍历二叉树，并返回和为target的路径void findPaths(struct TreeNode* root, int target, int sum, struct TreeNode*** paths, int* pathSize) {if (root == NULL) {return;}sum -= root->val; // 更新当前路径的和if (sum == 0 && root->left == NULL && root->right == NULL) { // 找到和为target的路径struct TreeNode* path = (structTreeNode*)malloc(sizeof(struct TreeNode));path->val = root->val;path->left = NULL;path->right = NULL;*paths[*pathSize] = path;(*pathSize)++;return;}findPaths(root->left, target, sum, paths, pathSize); // 递归遍历左子树findPaths(root->right, target, sum, paths, pathSize); // 递归遍历右子树}int main() {// 构造一棵二叉树struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));root->val = 5;root->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));root->left->val = 4;root->left->left = NULL;root->left->right = NULL;root->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));root->right->val = 8;root->right->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));root->right->left->val = 11;root->right->left->left = NULL;root->right->left->right = NULL;root->right->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));root->right->right->val = 7;root->right->right->left = NULL;root->right->right->right = NULL;// 查找和为target的路径int target = 22;struct TreeNode** paths = NULL; // 存储路径的数组int pathSize = 0; // 路径数组的大小findPaths(root, target, target, &paths, &pathSize);// 输出找到的路径printf("Paths sum to %d:\n", target);for (int i = 0; i < pathSize; i++) {struct TreeNode* path = paths[i];while (path != NULL) {printf("%d ", path->val);path = path->left;}printf("\n");free(paths[i]); // 释放路径所占用的内存空间}free(paths); // 释放路径数组所占用的内存空间return 0;}```。
二叉排序树的c语言代码
二叉排序树（Binary Sort Tree）是一种特殊的二叉树，它或左子树或右子树为完全二叉树。
由于二叉排序树的特点，其每个节点的值均大于其左子树中的所有节点的值，且小于其右子树中的所有节点的值。
以下是一个简单的二叉排序树的C语言实现，包括插入、查找和删除操作。
```c#include <stdio.h>#include <stdlib.h>typedef struct Node {int data;struct Node *left;struct Node *right;} Node;// 创建一个新的节点Node* createNode(int data) {Node* newNode = (Node*)malloc(sizeof(Node));if (!newNode) {printf("内存分配失败\n");return NULL;}newNode->data = data;newNode->left = newNode->right = NULL;return newNode;}// 在二叉排序树中插入一个新的节点Node* insert(Node* root, int data) {if (!root) { // 如果树为空，创建新节点并返回根节点root = createNode(data);} else if (data <= root->data) { // 如果插入的数据小于当前节点的值，则在左子树中插入root->left = insert(root->left, data);} else { // 如果插入的数据大于当前节点的值，则在右子树中插入root->right = insert(root->right, data);}return root; // 返回插入后的根节点}// 在二叉排序树中查找一个值是否存在int search(Node* root, int data) {if (!root) { // 如果树为空，返回0表示未找到return 0;} else if (root->data == data) { // 如果找到，返回1表示找到return 1;} else if (data < root->data) { // 如果插入的数据小于当前节点的值，在左子树中查找return search(root->left, data);} else { // 如果插入的数据大于当前节点的值，在右子树中查找return search(root->right, data);}}// 在二叉排序树中删除一个节点，并返回被删除的节点指针（如果存在）Node* deleteNode(Node* root, int data) {if (!root) return NULL; // 如果树为空，直接返回NULL（空树）if (data < root->data) { // 如果要删除的值小于当前节点的值，则在左子树中查找并删除root->left = deleteNode(root->left, data);} else if (data > root->data) { // 如果要删除的值大于当前节点的值，则在右子树中查找并删除root->right = deleteNode(root->right, data);} else { // 如果要删除的节点就是当前节点，根据情况选择删除方式（左子树或右子树）if (root->left == NULL) { // 如果左子树为空，直接删除当前节点（只有根节点时）Node *temp = root; // 临时保存当前节点，用于释放内存后替换原节点指针为NULLfree(temp); // 释放内存空间后将原指针设为NULL} else if (root->right == NULL) { // 如果右子树为空，直接删除当前节点（只有一个节点时）Node *temp = root->left; // 临时保存左子树的根节点，用于替换原节点指针为左子树的根节点指针（此时原节点为空）free(root); // 释放原节点的内存空间后将原指针设为NULL（此时原节点为空）root = temp; // 将原指针设为新的根节点指针（此时原节点为空）} else { // 如果左右子树都存在，则找到右子树中的最小节点（即要被替换的节点），替换原节点指针为最小节点的指针（此时原节点为空）并删除最小节点（通过递归实现）Node *temp = root->right; // 临时保存右子树的根节点指针（即要被替换的节点）root->data = temp->data; // 将原节点的数据。
二叉树计算叶子节点的算法C语言版
二叉树计算叶子节点的算法C语言版二叉树是一种常见的数据结构，其中每个节点最多有两个子节点：左子节点和右子节点。
叶子节点是指没有子节点的节点。
计算二叉树的叶子节点数量可以通过递归或迭代来实现。
在本文中，我们将探讨在C语言中实现计算叶子节点的算法。
1.定义节点结构体首先，我们需要定义一个包含二叉树节点信息的结构体。
节点结构体应该至少包含一个整数值来保存节点的数据，并且需要包含指向左子节点和右子节点的指针。
```ctypedef struct TreeNodeint data;struct TreeNode* left;struct TreeNode* right;} TreeNode;```2.创建二叉树在开始计算叶子节点之前，我们需要先创建一个二叉树。
为了简化问题，我们将手动创建一个具有固定节点值的二叉树。
```cTreeNode* createBinaryTre//创建节点TreeNode* root = createNode(1); TreeNode* node2 = createNode(2); TreeNode* node3 = createNode(3); TreeNode* node4 = createNode(4); TreeNode* node5 = createNode(5); TreeNode* node6 = createNode(6); TreeNode* node7 = createNode(7); //连接节点root->left = node2;root->right = node3;node2->left = node4;node2->right = node5;node3->left = node6;node3->right = node7;return root;```在上面的代码中，我们使用`createNode`函数创建节点，并使用`->`运算符将节点连接起来形成一个二叉树。
二叉树c语言实现完整代码
二叉树c语言实现完整代码二叉树是一种非常常见的数据结构，它由节点和边组成，每个节点最多有两个子节点，分别称为左子节点和右子节点。
在计算机科学中，二叉树被广泛应用于搜索、排序、编译器等领域。
本文将介绍如何使用C语言实现二叉树的完整代码。
我们需要定义二叉树的节点结构体。
每个节点包含三个成员变量：数据、左子节点和右子节点。
代码如下：```struct TreeNode {int val;struct TreeNode *left;struct TreeNode *right;};```接下来，我们需要实现二叉树的基本操作，包括创建节点、插入节点、删除节点、查找节点等。
这些操作可以通过递归实现。
代码如下：```// 创建节点struct TreeNode* createNode(int val) {struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));node->val = val;node->left = NULL;node->right = NULL;return node;}// 插入节点struct TreeNode* insertNode(struct TreeNode* root, int val) {if (root == NULL) {return createNode(val);}if (val < root->val) {root->left = insertNode(root->left, val);} else {root->right = insertNode(root->right, val);}return root;}// 删除节点struct TreeNode* deleteNode(struct TreeNode* root, int val) {if (root == NULL) {return NULL;}if (val < root->val) {root->left = deleteNode(root->left, val);} else if (val > root->val) {root->right = deleteNode(root->right, val);} else {if (root->left == NULL) {struct TreeNode* temp = root->right;free(root);return temp;} else if (root->right == NULL) {struct TreeNode* temp = root->left;free(root);return temp;}struct TreeNode* temp = findMin(root->right); root->val = temp->val;root->right = deleteNode(root->right, temp->val); }return root;}// 查找节点struct TreeNode* searchNode(struct TreeNode* root, int val) {if (root == NULL || root->val == val) {return root;}if (val < root->val) {return searchNode(root->left, val);} else {return searchNode(root->right, val);}}// 查找最小节点struct TreeNode* findMin(struct TreeNode* root) {while (root->left != NULL) {root = root->left;}return root;}```我们需要实现二叉树的遍历操作，包括前序遍历、中序遍历和后序遍历。
数据结构-C语言-树和二叉树
练习
一棵完全二叉树有5000个结点，可以计算出其
叶结点的个数是（ 2500）。
二叉树的性质和存储结构
性质4: 具有n个结点的完全二叉树的深度必为[log2n]＋1
k-1层 k层
2k−1−1＜n≤2k−1 或 2k−1≤n＜2k n k−1≤log2n＜k，因为k是整数
所以k = log2n + 1
遍历二叉树和线索二叉树
遍历定义
指按某条搜索路线遍访每个结点且不重复（又称周游）。
遍历用途
它是树结构插入、删除、修改、查找和排序运算的前提， 是二叉树一切运算的基础和核心。
遍历规则 D
先左后右
L
R
DLR LDR LRD DRL RDL RLD
遍历规则
A BC DE
先序遍历：A B D E C 中序遍历：D B E A C 后序遍历：D E B C A
练习 具有3个结点的二叉树可能有几种不同形态？普通树呢？
5种/2种
目 录 导 航 Contents
5.1 树和二叉树的定义 5.2 案例引入 5.3 树和二叉树的抽象数据类型定义 5.4 二叉树的性质和存储结构 5.5 遍历二叉树和线索二叉树 5.6 树和森林 5.7 哈夫曼树及其应用 5.8 案例分析与实现
(a + b *(c-d)-e/f)的二叉树
目 录 导 航 Contents
5.1 树和二叉树的定义 5.2 案例引入 5.3 树和二叉树的抽象数据类型定义 5.4 二叉树的性质和存储结构 5.5 遍历二叉树和线索二叉树 5.6 树和森林 5.7 哈夫曼树及其应用 5.8 案例分析与实现
二叉树的抽象数据类型定义
特殊形态的二叉树
只有最后一层叶子不满，且全部集中在左边
二叉树 c语言
二叉树 c语言在计算机科学领域中，树型数据结构是一种非常重要的数据结构，在实际开发中也得到了广泛的应用。
其中，二叉树又是一种非常常见的树型结构。
二叉树在很多情况下都能够提供更好的算法效率，同时也易于理解和实现，因此我们可以通过通过学习和掌握二叉树的特点以及优点，来更好的应用到实际开发中。
一、二叉树的定义二叉树是一种树型结构，树型结构是由节点构成的。
二叉树与一般的树型结构不同，它的每个节点最多只有两个子节点，分别称为左子树和右子树。
它们可以为空或者不为空，其子节点的数量时不固定且没有任何限制的。
二叉树的定义如下：（1）空树是树的一种特殊的状态。
我们可以把它称为二叉树；（2）若不是空树，那么它就是由一个称为根节点（root）的元素和左右两棵分别称为左子树（left subtree）和右子树（right subtree）的二叉树组成。
二、二叉树的特性（1）每个节点最多只有两个子节点，分别称为左子节点和右子节点；（2）左子树和右子树是二叉树；（3）二叉树没有重复的节点。
三、二叉树的应用二叉树是一种非常实用的数据结构，因为它可以模拟很多实际生活中的情况。
例如，我们可以利用二叉树来对某些数据进行分类和排序。
在二叉树的基础上，我们还可以构造二叉堆、哈夫曼树等更高级的数据结构。
除此之外，二叉树还可以应用到程序设计中。
例如，我们可以构造一个二叉树来表示某个程序的控制流，这个程序在执行时可以沿着二叉树的各个节点进行分支和选择，实现不同的功能。
此外，我们还可以利用二叉树来加快某些算法的执行效率，比如二分查找算法等。
四、二叉树的遍历方式对于二叉树的遍历，有三种基本方式，即前序遍历、中序遍历、后序遍历。
它们的遍历顺序不同，因此也得到了不同的称呼。
下面我们来简要介绍一下这三种遍历方式的特点和应用。
（1）前序遍历前序遍历是指首先访问树的根节点，然后按照从左到右的顺序依次遍历左子树和右子树。
前序遍历的应用非常广泛，可以用于生成表达式树、构造二叉树等等。
C语言二叉树的实际应用场景
C语言二叉树的实际应用场景
树是一种重要的非线性数据结构，直观地看，它是数据元素（在树中称为结点）按分支关系组织起来的结构，很像自然界中的树那样。
树结构在客观世界中广泛存在，如人类社会的族谱和各种社会组织机构都可用树形象表示。
树在计算机领域中也得到广泛应用，如在编译源程序如下时，可用树表示源程序如下的语法结构。
又如在数据库系统中，树型结构也是信息的重要组织形式之一。
一切具有层次关系的问题都可用树来描述。
分为满二叉树，完全二叉树，排序二叉树。
1、哈夫曼编码，来源于哈夫曼树【给定n个权值作为n个叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为赫夫曼树（Huffman tree）。
即带权路径长度最短的树】，在数据压缩上有重要应用，提高了传输的有效性，详见《信息论与编码》。
2、海量数据并发查询，二叉树复杂度是O（K+LgN）。
二叉排序树就既有链表的好处，也有数组的好处，在处理大批量的动态的数据是比较有用。
3、C++STL中的set/multiset、map，以及Linux虚拟内存的管理，都是通过红黑树去实现的。
查找最大（最小）的k个数，红黑树，红黑树中查找/删除/插入，都只需要O（logk）。
4、B-Tree，B+-Tree在文件系统中的目录应用。
5、路由器中的路由搜索引擎。
C语言数据结构系列篇二叉树的概念及满二叉树与完全二叉树
C语⾔数据结构系列篇⼆叉树的概念及满⼆叉树与完全⼆叉树链接：0x00 概念定义：⼆叉树既然叫⼆叉树，顾名思义即度最⼤为2的树称为⼆叉树。
它的度可以为 1 也可以为 0，但是度最⼤为 2 。
⼀颗⼆叉树是节点的⼀个有限集合，该集合：①由⼀个根节点加上两颗被称为左⼦树和右⼦树的⼆叉树组成②或者为空观察上图我们可以得出如下结论：①⼆叉树不存在度⼤于 2 的节点，换⾔之⼆叉树最多也只能有两个孩⼦。
②⼆叉树的⼦树有左右之分，分别为左孩⼦和右孩⼦。
次序不可颠倒，因此⼆叉树是有序树。
注意：对于任意的⼆叉树都是由以下⼏种情况复合⽽成的：0x01 满⼆叉树定义：⼀个⼆叉树，如果每⼀层的节点数都达到了最⼤值（均为2），则这个⼆叉树就可以被称作为 "满⼆叉树" 。
换⾔之，如果⼀个⼆叉树的层数为，且节点总数是，则他就是⼀个满⼆叉树。
计算公式：①已知层数求总数：②已知总数求层数：⼗亿个节点，满⼆叉树是多少层？≈ 10亿多0x02 完全⼆叉树定义：对于深度为的，有个结点的⼆叉树，当且仅当其每⼀个结点都与深度为的满⼆叉树中编号从 1 ⾄的结点⼀⼀对应时称之为完全⼆叉树。
前层是满的，最后⼀层不满，但是最后⼀层从左到右是连续的。
完全⼆叉树是效率很⾼的数据结构，完全⼆叉树是由满⼆叉树⽽引出来的。
所以，满⼆叉树是⼀种特殊的完全⼆叉树（每⼀层节点均为2）。
常识：①完全⼆叉树中，度为 1 的最多只有 1 个。
②⾼度为的完全⼆叉树节点范围是0x03 ⼆叉树的性质①若规定根节点的层数为 1 ，则⼀颗⾮空⼆叉树的第层上最多有个节点。
②若规定根节点的层数为 1 ，则深度为的⼆叉树最⼤节点数是 .③对任何⼀颗⼆叉树，如果度为 0 其叶⼦结点个数为，度为 2 的分⽀节点个数为，则有。
换⾔之，度为 0 的永远⽐度为 2 的多⼀个叶⼦结点。
④若规定根节点的层数为 1 ，具有个节点的满⼆叉树的深度（log是以2为底，n+1的对数）。
对于有个节点的完全⼆叉树，如果按照从上⾄下从左⾄右的数组顺序对所有节点从 0 开始编号，则对于序号为的节点有：（⾮完全⼆叉树，也可以⽤数组存放，但会浪费很多空间）假设是⽗节点在数组中的下标，此公式仅适⽤于完全⼆叉树：①求左孩⼦：②求右孩⼦：③求⽗亲（假设不关注是左孩⼦还是右孩⼦）：④判断是否有左孩⼦：⑤判断是否由右孩⼦：PS：⼆叉树不⼀定要标准，⽐如这个其实也是⼆叉树：课后练习：1. 某⼆叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该⼆叉树中的叶⼦结点数为（）A. 不存在这样的⼆叉树B. 200C. 1982. 在具有 2n 个结点的完全⼆叉树中，叶⼦结点个数为（）A. nB. n+1C. n-1D. n/23. ⼀棵完全⼆叉树的节点数位为531个，那么这棵树的⾼度为（）A. 11B. 10C. 8D. 125. ⼀个具有767个节点的完全⼆叉树，其叶⼦节点个数为（）A. 383B. 384C. 385D. 386参考资料：Microsoft. MSDN(Microsoft Developer Network)[EB/OL]. []. .笔者：王亦优更新： 2021.11.24勘误：⽆声明：由于作者⽔平有限，本⽂有错误和不准确之处在所难免，本⼈也很想知道这些错误，恳望读者批评指正！本篇完。
摩斯密码 c语言 二叉树
摩斯密码 c语言二叉树摩斯密码是一种将字母和数字转换为短信号和长信号的编码方式。
在莫尔斯电码中，点表示短信号，横线表示长信号。
二叉树是一种树状数据结构，其中每个节点最多有两个子节点。
二叉树可以用于搜索和排序，以及在计算机科学中的其他许多应用程序。
以下是使用C语言实现摩斯密码和二叉树：摩斯密码：```。
#include <stdio.h>。
#include <string.h>。
int main ()。
char msg[100];。
char morse[26][5] = {".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."};。
int i, j;。
printf("Enter a message to convert to Morse code: ");。
fgets(msg, sizeof(msg), stdin);。
msg[strlen(msg)-1] = '\0';。
二叉树实现及应用实验报告
二叉树实现及应用实验报告实验名称：二叉树实现及应用实验目的：1. 实现二叉树的创建、插入和删除操作。
2. 学习二叉树的遍历方法，并能够应用于实际问题。
3. 掌握二叉树在数据结构和算法中的一些常用应用。
实验内容：1. 实现二叉树的创建、插入和删除操作，包括二叉树的构造函数、插入函数和删除函数。
2. 学习二叉树的三种遍历方法：前序遍历、中序遍历和后序遍历，并应用于实际问题。
3. 掌握二叉树的一些常用应用，如二叉搜索树、平衡二叉树和哈夫曼树等。
实验步骤：1. 创建二叉树的结构体，包括树节点和树的根节点。
2. 实现二叉树的构造函数，用于创建二叉树的根节点。
3. 实现二叉树的插入函数，用于将元素插入到二叉树中的合适位置。
4. 实现二叉树的删除函数，用于删除二叉树中的指定元素。
5. 学习并实现二叉树的前序遍历、中序遍历和后序遍历函数。
6. 运用二叉树的遍历方法解决实际问题，如查找二叉树中的最大值和最小值。
7. 学习并应用二叉搜索树、平衡二叉树和哈夫曼树等常用二叉树结构。
实验结果：1. 成功创建、插入和删除二叉树中的元素，实现了二叉树的基本操作。
2. 正确实现了二叉树的前序遍历、中序遍历和后序遍历，并能够正确输出遍历结果。
3. 通过二叉树的遍历方法成功解决了实际问题，如查找二叉树中的最大值和最小值。
4. 学习并熟练应用了二叉搜索树、平衡二叉树和哈夫曼树等常用二叉树结构，丰富了对二叉树的理解。
实验分析：1. 二叉树是一种重要的数据结构，具有较好的数据存储和查找性能，广泛应用于计算机科学和算法领域。
2. 通过实验，我们深入了解了二叉树的创建、插入和删除操作，以及前序遍历、中序遍历和后序遍历的原理和应用。
3. 实际问题往往可以转化为二叉树的遍历问题进行求解，通过实验，我们成功应用了二叉树的遍历方法解决了实际问题。
4. 熟练掌握二叉搜索树、平衡二叉树和哈夫曼树的原理和应用，对于提高我们在数据结构和算法方面的设计能力具有重要意义。
数据结构——用C语言描述(第3版)教学课件第6章 树与二叉树
6.2 二叉树 6.2.1 二叉树的定义与基本操作 6.2.2 二叉树的性质 6.2.3 二叉树的存储结构
6.2.1 二叉树的定义与基本操作 定义：我们把满足以下两个条件的树型结构叫做二 叉树（Binary Tree）： （1）每个结点的度都不大于2； （2）每个结点的孩子结点次序不能任意颠倒。
有序树：在树T中，如果各子树Ti之间是有先后次序的，则称为有序树。 森林：m（m≥0）棵互不相交的树的集合。将一棵非空树的根结点删去，树就变成一 个森林；反之，给森林增加一个统一的根结点，森林就变成一棵树。
同构：对两棵树，通过对结点适当地重命名，就可以使两棵树完全相等（结点对应相 等，对应结点的相关关系也像等），则称这两棵树同构。
二叉树的基本结构由根结点、左子树和右子树组成
如图示
LChild Data RChild
Data
LChild RChild
用L、D、R分别表示遍历左子树、访问根结点、遍 历右子树，那么对二叉树的遍历顺序就可以有：
(1) 访问根，遍历左子树，遍历右子树(记做DLR)。 (2) 访问根，遍历右子树，遍历左子树(记做DRL)。 (3) 遍历左子树，访问根，遍历右子树(记做LDR)。 (4) 遍历左子树，遍历右子树，访问根 (记做LRD)。 (5) 遍历右子树，访问根，遍历左子树 (记做RDL)。 (6) 遍历右子树，遍历左子树，访问根 (记做RLD)。
(8) NextSibling（Tree，x）： 树Tree存在，x是Tree中的某个结点。若x不 是其双亲的最后一个孩子结点，则返回x后面的下一个兄弟结点，否则 返回“空”。
基本操作:
(9) InsertChild（Tree，p，Child）： 树Tree存在，p指向Tree 中某个结点，非空树Child与Tree不相交。将Child插入Tree中， 做p所指向结点的子树。
C语言实现二叉树的中序遍历（递归）
C语 言 实 现 二 叉 树 的 中 序 遍 历 （ 递 归 ）
二叉树的前序遍历、中序遍历、后续遍历 （包括递归、非递归，共六种） 1、中序遍历（递归）： #include #include struct BiTNode//定义结构体 { char data; struct BiTNode *lchild,*rchild; }; void later(struct BiTNode *&p) //前序创建树 { char ch; scanf("%c",&ch); if(ch==' ') p=NULL; else { p=(struct BiTNode *)malloc(sizeof(struct BiTNode)); p->data=ch; later(p->lchild); later(p->rchild); } } void print(struct BiTNode *p) //中序遍历（输出二叉树） { if(p!=NULL) { print(p->lchild); printf("%c",p->data); print(p->rchild); } else printf(" ");
c语言使用括号表示法输入二叉树并转化为二叉树的链式存储结构 -回复
c语言使用括号表示法输入二叉树并转化为二叉树的链式存储结构-回复C语言中二叉树的链式存储结构是一种常见且有效的数据结构，可以以节点的形式表示二叉树，使得对二叉树的操作更加灵活和高效。
在这篇文章中，我们将详细讨论如何使用括号表示法输入二叉树并转化为二叉树的链式存储结构。
第一步：了解二叉树的定义和特点在开始讨论之前，我们需要先明确二叉树的定义和特点。
二叉树是一种树形结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。
二叉树的链式存储结构利用节点之间的指针连接，将二叉树的节点表示为一个结构体。
typedef struct TreeNode {int data; 节点数据struct TreeNode* leftChild; 左子节点指针struct TreeNode* rightChild; 右子节点指针} TreeNode;第二步：了解括号表示法和二叉树的对应关系括号表示法是一种使用括号和逗号表示二叉树结构的方法。
在括号表示法中，每个节点的左子节点可以被表示为“(”，右子节点可以被表示为“)”，而逗号用于分隔每个节点。
例如，下面是一个使用括号表示法表示的二叉树：((4), ((7), (8, (6)), (9, ()), ()), (2), ((5), ((1), ()), (3, (), (10))))第三步：构建转化函数使用括号表示法输入的二叉树需要经过一定的处理，才能将其转化为二叉树的链式存储结构。
为了完成这个转化过程，我们可以定义一个递归函数，该函数接收一个字符串作为输入，并返回根节点的指针。
TreeNode* convertToBinaryTree(char* str) {static int index = 0;TreeNode* root = NULL;if (str[index] == '(') {index++;if (str[index] != ')') {root = malloc(sizeof(TreeNode));sscanf(&str[index], "d", &root->data);root->leftChild = convertToBinaryTree(str);root->rightChild = convertToBinaryTree(str);}index++;}return root;}第四步：编写测试代码为了验证上述转化函数的正确性，我们需要编写一些测试代码。
完全二叉树计数c语言
完全二叉树计数c语言完全二叉树是一种特殊的二叉树结构，它的每一层都是满的，除了最后一层外，其他层的节点数都是满的。
本文将介绍完全二叉树的计数方法，并用C语言实现。
完全二叉树的计数问题是一个经典的数学问题，也是计算机科学中的重要内容。
在解决这个问题之前，我们先来了解一下完全二叉树的特点和性质。
完全二叉树具有以下性质：1. 如果完全二叉树的深度为h，那么叶子节点的个数为2^(h-1)到2^h-1之间。
2. 完全二叉树的节点数为2^h-1个，其中h为完全二叉树的深度。
3. 完全二叉树的第i个节点，如果i大于1，则其父节点为i/2，左子节点为2i，右子节点为2i+1。
现在我们来考虑如何计算完全二叉树的节点数。
一种简单的方法是遍历整个二叉树，统计节点的个数。
但是这种方法的时间复杂度较高，为O(n)，其中n是节点的个数。
我们可以使用数学的方法来计算完全二叉树的节点数。
假设完全二叉树的深度为h，节点数为n。
根据性质1，叶子节点的个数为2^(h-1)到2^h-1之间，即2^(h-1) <= n <= 2^h-1。
我们可以通过不断调整h的值，来逼近n的值。
我们可以确定n的上界，即2^h-1。
然后，我们可以使用二分法来逼近n的值。
假设当前的上界为upper，下界为lower，中点为mid。
如果mid是一个可能的节点数，那么我们将上界调整为mid，否则将下界调整为mid+1。
这样，我们可以在O(logn)的时间内找到最接近n的节点数。
下面是使用C语言实现完全二叉树计数的代码：```c#include <stdio.h>// 计算完全二叉树的节点数int countNodes(int n) {int h = 0; // 完全二叉树的深度int upper = 1; // 节点数的上界int lower = 0; // 节点数的下界// 确定完全二叉树的深度while (n >= upper) {lower = upper;upper = upper * 2;h++;}// 使用二分法逼近节点数while (lower < upper) {int mid = lower + (upper - lower) / 2;if (mid < n && mid * 2 <= n) {lower = mid + 1;} else {upper = mid;}}return upper;}int main() {int n;printf("请输入完全二叉树的节点数：");scanf("%d", &n);int count = countNodes(n);printf("完全二叉树的节点数为：%d\n", count);return 0;}```在上面的代码中，我们首先确定完全二叉树的深度h，然后使用二分法逼近节点数。
浅析一种二叉树非递归遍历算法的C语言实现论文.doc
浅析一种二叉树非递归遍历算法的C语言实现论文一种二叉树非递归遍历算法的C语言实现论文导读：本论文是一篇关于一种二叉树非递归遍历算法的C语言实现的优秀论文范文,对正在写有关于递归论文的写有一定的参考和指导作用,摘要：针对二叉树的链式存储结构，分析了二叉树的各种遍历算法，探讨了递归算法的递推消除理由，提出了一种改善的非递归遍历算法并用C语言予以实现。
关键词：二叉树；遍历算法；非递归；C语言实现1009-3044（2014）01-0223-031 概述树形结构是一种非常常见的数据结构，而二叉树又是其中最重要的一种树形结构。
二叉树的遍历是指按照一定的规则和次序将二叉树中的每一个结点都访问一次，既不能重复，也不能漏掉。
一般而言，对二叉树的遍历有前序遍历、中序遍历、后序遍历和按层遍历等几种方式。
在具体的算法设计上，以上遍历方式一般采取递归算法来实现，该文将探讨采用非递归算法来实现二叉树的遍历。
2 二叉树的数据结构描述二叉树作为一种非线性结构，每个结点最多有一个双亲结点和两个子结点。
二叉树可以采用顺序存储结构和链式存储结构。
对于完全二叉树而言，采用顺序存储是非常方便并且节省空间的，但是对于大部分的非完全二叉树而言，采用顺序存储将导致空间浪费严重且结构混乱、效率低下。
因此，更多的时候，大家都更愿意用链式存储结构来表示二叉树，这样结构更加清晰，尤其是对于一种二叉树非递归遍历算法的C语言实现由写论文的好帮手.zbjy.提供,.左右子树的描述和双亲节点的描述更加方便。
该文中拟采用链式结构来表示二叉树。
用链式存储结构来表示二叉树，一个结点至少由3个域组成，即数据域、左子结点域和右子结点域（如图1所示）。
3 二叉树的遍历及递归算法实现3.1 二叉树的遍历二叉树的遍历就是一个不漏的访问树中的每个结点，同时也不能重复。
所谓“访问”，就是指对结点的数据域进行某种操作，比如说读取、删除、更新、求该节点深度等等。
对于二叉树中的任意一个部分，都可以把它看作三部分，根节点、左子树、右子树，我们用D表示访问跟结点，用L表示遍历左子树，用R表示遍历右子树，则共有以下6种遍历方式[1]。
用C语言编写二叉树的建立与遍历
用C语言编写二叉树的建立与遍历1．对题目要有需求分析在需求分析中，将题目中要求的功能进行叙述分析，并且设计解决此问题的数据存储结构，设计或叙述解决此问题的算法。
给出实现功能的一组或多组测试数据，程序调试后，将按照此测试数据进行测试的结果列出来。
如果程序不能正常运行，写出实现此算法中遇到的问题和改进方法；2．对题目要有相应的源程序源程序要按照写程序的规则来编写。
要结构清晰，重点函数的重点变量，重点功能部分要加上清晰的程序注释。
(注释量占总代码的四分之一)程序能够运行，要有基本的容错功能。
尽量避免出现操作错误时出现死循环；3．最后提供的主程序可以象一个应用系统一样有主窗口，通过主菜单和分级菜单调用课程设计中要求完成的各个功能模块，调用后可以返回到主菜单，继续选择其他功能进行其他功能的选择。
二叉树的建立与遍历[问题描述]建立一棵二叉树，并对其进行遍历（先序、中序、后序），打印输出遍历结果。
[基本要求]从键盘接受输入，以二叉链表作为存储结构，建立二叉树，并对其进行遍历（先序、中序、后序），将遍历结果打印输出。
以下是我的数据结构实验的作业：肯定好用，里面还包括了统计树的深度和叶子数！记住每次做完一个遍历还要重新输入你的树哦！#include "stdio.h"#include "string.h"#define NULL 0typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;BiTree Create(BiTree T){char ch;ch=getchar();if(ch=='#')T=NULL;else{if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))printf("Error!");T->data=ch;T->lchild=Create(T->lchild);T->rchild=Create(T->rchild); }return T;}void Preorder(BiTree T){if(T){printf("%c",T->data); Preorder(T->lchild); Preorder(T->rchild);}}int Sumleaf(BiTree T){int sum=0,m,n;if(T){if((!T->lchild)&&(!T->rchild)) sum++;m=Sumleaf(T->lchild);sum+=m;n=Sumleaf(T->rchild);sum+=n;}return sum;}void zhongxu(BiTree T){if(T){zhongxu(T->lchild);printf("%c",T->data); zhongxu(T->rchild);}}void houxu(BiTree T){if(T){houxu(T->lchild);houxu(T->rchild);printf("%c",T->data);}}int Depth(BiTree T){int dep=0,depl,depr;if(!T) dep=0;else{depl=Depth(T->lchild);depr=Depth(T->rchild);dep=1+(depl>depr?depl:depr);}return dep;}main(){BiTree T;int sum,dep;T=Create(T);Preorder(T);printf("\n");zhongxu(T);printf("\n");houxu(T);printf("\n");sum=Sumleaf(T);printf("%d",sum);dep=Depth(T);printf("\n%d",dep);}在Turbo C的环境下，先按Ctrl+F9运行程序，此时就是建立二叉树的过程，例如输入序列ABC##DE#G##F###（其中的“#”表示空，并且输入过程中不要加回车，因为回车也有对应的ASCII码，是要算字符的，但是输入完之后可以按回车退出），然后再按ALT+F5显示用户界面，这时候就能够看到结果了。
c语言实现二叉树各种基本运算的算法
c语言实现二叉树各种基本运算的算法二叉树是一种常见的数据结构，可以应用于许多算法和问题中。
在C语言中，我们可以使用指针和结构体来实现二叉树的各种基本运算。
本文将详细介绍二叉树的创建、插入、删除、查找以及遍历等基本操作的算法。
1.创建二叉树创建二叉树可以通过递归的方式来实现。
首先定义一个表示二叉树节点的结构体，包含一个值和左右子节点指针。
然后，通过递归地创建左右子树来构建整个二叉树。
```ctypedef struct TreeNode {int data;struct TreeNode* left;struct TreeNode* right;} TreeNode;//创建二叉树TreeNode* createBinaryTree() {int data;scanf("%d", &data);if (data == -1) { // -1表示空节点return NULL;}TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode)); node->data = data;node->left = createBinaryTree();node->right = createBinaryTree();return node;}```2.插入节点在二叉树中插入节点可以按照二叉搜索树的性质进行。
如果要插入的值小于当前节点的值，则将其插入到左子树中，否则插入到右子树中。
如果子树为空，则直接创建一个新节点作为子树。
```c//插入节点TreeNode* insertNode(TreeNode* root, int data) {if (root == NULL) {TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));newNode->data = data;newNode->left = NULL;newNode->right = NULL;return newNode;}if (data < root->data) {root->left = insertNode(root->left, data);} else {root->right = insertNode(root->right, data);}return root;}```3.删除节点删除二叉树中的节点可以分为三种情况：删除叶子节点、删除只有一个子节点的节点、删除有两个子节点的节点。
c语言非递归二叉树节点总数 解释说明以及概述
c语言非递归二叉树节点总数解释说明以及概述1. 引言1.1 概述这篇长文将介绍非递归二叉树节点总数的概念、实现方法以及其在应用领域中的重要性。
通过使用C语言编写代码示例，我们将展示如何利用循环迭代来计算二叉树节点的总数。
此外，还会包括一些总结论点，以便更好地理解和应用这个知识。
1.2 文章结构这篇文章分为四个主要部分：引言、非递归二叉树节点总数解释说明、C语言实现非递归二叉树节点总数的代码示例以及结论。
每个部分都会详细说明相关内容，并提供必要的代码示例和解释。
1.3 目的本文旨在帮助读者了解什么是非递归二叉树节点总数，并提供一种使用C语言进行计算的方法。
通过掌握这些概念和技巧，读者可以更好地理解并应用于相关领域，如数据结构和算法设计等。
2. 非递归二叉树节点总数解释说明：2.1 什么是非递归二叉树节点总数：非递归二叉树节点总数指的是在一棵二叉树中，通过使用非递归的方式计算出该二叉树所含有的节点数量。
节点总数是衡量一棵二叉树规模的重要指标之一，对于算法和数据结构的研究和应用具有重要意义。
2.2 实现非递归二叉树节点总数的方法：实现非递归二叉树节点总数可以通过遍历整个二叉树并计算遍历过程中经过的节点个数来实现。
常用的遍历方式包括先序遍历、中序遍历和后序遍历。
在进行非递归遍历时，通常会利用辅助数据结构，如栈或队列来存储待访问的节点，并通过循环迭代的方式完成遍历。
2.3 应用领域和重要性：非递归二叉树节点总数在计算机科学中有着广泛的应用。
它可以被应用于数据分析、图像处理、机器学习等领域。
在对大规模数据进行处理时，使用非递归方法可以提高计算效率，避免了递归调用产生的函数调用开销。
通过准确计算二叉树节点总数，可以更好地评估二叉树结构的复杂度，并对其进行优化。
以上是对非递归二叉树节点总数的解释说明，接下来将通过C语言实现一个非递归二叉树节点总数的代码示例，以进一步说明和展示如何实现该功能。
3. C语言实现非递归二叉树节点总数的代码示例：在这一部分，我们将详细介绍如何使用C语言来实现非递归二叉树节点总数的计算。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
/************************************************************************/二叉树在C语言中的实现与应用/************************************************************************/#include <stdio.h>#include <stdlib.h>#define STACK_MAX_SIZE 30#define QUEUE_MAX_SIZE 30#ifndef elemTypetypedef char elemType;#endif/************************************************************************//* 以下是关于二叉树操作的11个简单算法 *//************************************************************************/ struct BTreeNode{elemType data;struct BTreeNode *left;struct BTreeNode *right;};/* 1.初始化二叉树 */void initBTree(struct BTreeNode* *bt){*bt = NULL;return;}/* 2.建立二叉树(根据a所指向的二叉树广义表字符串建立) */void createBTree(struct BTreeNode* *bt, char *a){struct BTreeNode *p;struct BTreeNode *s[STACK_MAX_SIZE];/* 定义s数组为存储根结点指针的栈使用 */int top = -1; /* 定义top作为s栈的栈顶指针，初值为-1,表示空栈 */int k; /* 用k作为处理结点的左子树和右子树，k = 1处理左子树，k = 2处理右子树 */ int i = 0; /* 用i扫描数组a中存储的二叉树广义表字符串，初值为0 */*bt = NULL; /* 把树根指针置为空，即从空树开始建立二叉树 *//* 每循环一次处理一个字符，直到扫描到字符串结束符\0为止 */while(a[i] != '\0'){switch(a[i]){case ' ':break; /* 对空格不作任何处理 */case '(':if(top == STACK_MAX_SIZE - 1){printf("栈空间太小！\n");exit(1);}top++;s[top] = p;k = 1;break;case ')':if(top == -1){printf("二叉树广义表字符串错误!\n");exit(1);}top--;break;case ',':k = 2;break;default:p = new BTreeNode ;p->data = a[i];p->left = p->right = NULL;if(*bt == NULL){*bt = p;}else{if( k == 1){s[top]->left = p;}else{s[top]->right = p;}}}i++; /* 为扫描下一个字符修改i值 */}return;}/* 3.检查二叉树是否为空，为空则返回1,否则返回0 */ int emptyBTree(struct BTreeNode *bt){if(bt == NULL){return 1;}else{return 0;}}/* 4.求二叉树深度 */int BTreeDepth(struct BTreeNode *bt){if(bt == NULL){return 0; /* 对于空树，返回0结束递归 */}else{int dep1 = BTreeDepth(bt->left); /* 计算左子树的深度 */int dep2 = BTreeDepth(bt->right); /* 计算右子树的深度 */if(dep1 > dep2){return dep1 + 1;}else{return dep2 + 1;}}}/* 5.从二叉树中查找值为x的结点，若存在则返回元素存储位置，否则返回空值 */ elemType *findBTree(struct BTreeNode *bt, elemType x){if(bt == NULL){return NULL;}else{if(bt->data == x){return &(bt->data);}else{ /* 分别向左右子树递归查找 */elemType *p;if(p = findBTree(bt->left, x)){return p;}if(p = findBTree(bt->right, x)){return p;}return NULL;}}}/* 6.输出二叉树(前序遍历) */void printBTree(struct BTreeNode *bt){/* 树为空时结束递归，否则执行如下操作 */if(bt != NULL){printf("%c", bt->data); /* 输出根结点的值 */if(bt->left != NULL || bt->right != NULL){printf("(");printBTree(bt->left);if(bt->right != NULL){printf(",");}printBTree(bt->right);printf(")");}}return;}/* 7.清除二叉树，使之变为一棵空树 */void clearBTree(struct BTreeNode* *bt) {if(*bt != NULL){clearBTree(&((*bt)->left));clearBTree(&((*bt)->right));free(*bt);*bt = NULL;}return;}/* 8.前序遍历 */void preOrder(struct BTreeNode *bt){if(bt != NULL){printf("%c ", bt->data); /* 访问根结点 */ preOrder(bt->left); /* 前序遍历左子树 */ preOrder(bt->right); /* 前序遍历右子树 */ }return;}/* 9.前序遍历 */void inOrder(struct BTreeNode *bt){if(bt != NULL){inOrder(bt->left); /* 中序遍历左子树 */ printf("%c ", bt->data); /* 访问根结点 */ inOrder(bt->right); /* 中序遍历右子树 */ }return;}/* 10.后序遍历 */void postOrder(struct BTreeNode *bt){if(bt != NULL){postOrder(bt->left); /* 后序遍历左子树 */ postOrder(bt->right); /* 后序遍历右子树 */ printf("%c ", bt->data); /* 访问根结点 */ }return;}/* 11.按层遍历 */void levelOrder(struct BTreeNode *bt){struct BTreeNode *p;struct BTreeNode *q[QUEUE_MAX_SIZE];int front = 0, rear = 0;/* 将树根指针进队 */if(bt != NULL){rear = (rear + 1) % QUEUE_MAX_SIZE;q[rear] = bt;}while(front != rear){ /* 队列非空 */front = (front + 1) % QUEUE_MAX_SIZE; /* 使队首指针指向队首元素 */p = q[front];printf("%c ", p->data);/* 若结点存在左孩子，则左孩子结点指针进队 */if(p->left != NULL){rear = (rear + 1) % QUEUE_MAX_SIZE;#include <stdio.h>#include <stdlib.h>#define STACK_MAX_SIZE 30#define QUEUE_MAX_SIZE 30#ifndef elemTypetypedef char elemType ;#endif/************************************************************************//* 以下是关于二叉树操作的11个简单算法 *//************************************************************************/struct BTreeNode{elemType data ;struct BTreeNode *left ;struct BTreeNode *right ;};/* 1.初始化二叉树 */void initBTree(struct BTreeNode* *bt){*bt = NULL ;return ;}/* 2.建立二叉树(根据a所指向的二叉树广义表字符串建立) */void createBTree(struct BTreeNode* *bt, char *a){struct BTreeNode *p;struct BTreeNode *s[STACK_MAX_SIZE];/* 定义s数组为存储根结点指针的栈使用 */int top = -1; /* 定义top作为s栈的栈顶指针，初值为-1,表示空栈 */int k ; /* 用k作为处理结点的左子树和右子树，k = 1处理左子树，k = 2处理右子树 */ int i = 0 ; /* 用i扫描数组a中存储的二叉树广义表字符串，初值为0 */*bt = NULL ; /* 把树根指针置为空，即从空树开始建立二叉树 *//* 每循环一次处理一个字符，直到扫描到字符串结束符\0为止 */ while(a[i] != '\0'){switch(a[i]){case ' ':break; /* 对空格不作任何处理 */case '(':if( top == STACK_MAX_SIZE - 1 ){printf("栈空间太小！\n") ;exit(1) ;}top++ ;s[top] = p ;k = 1 ;break;case ')':if(top == -1){printf("二叉树广义表字符串错误!\n");exit(1);}top-- ;break ;case ',':k = 2;break;default:p = new BTreeNode ;p->data = a[i] ;p->left = p->right = NULL ;if( *bt == NULL){*bt = p ;}else{if( k == 1){s[top]->left = p ;}else{s[top]->right = p ;}}}i++ ; /* 为扫描下一个字符修改i值 */}return;}/* 3.检查二叉树是否为空，为空则返回1,否则返回0 */int emptyBTree(struct BTreeNode *bt){if(bt == NULL){return 1;}else{return 0;}}/* 4.求二叉树深度 */int BTreeDepth(struct BTreeNode *bt){if(bt == NULL){return 0; /* 对于空树，返回0结束递归 */}else{int dep1 = BTreeDepth(bt->left); /* 计算左子树的深度 */int dep2 = BTreeDepth(bt->right); /* 计算右子树的深度 */if(dep1 > dep2){return dep1 + 1;}else{return dep2 + 1;}}}/* 5.从二叉树中查找值为x的结点，若存在则返回元素存储位置，否则返回空值 */ elemType *findBTree(struct BTreeNode *bt, elemType x){if(bt == NULL){return NULL;}else{if(bt->data == x){return &(bt->data);}else{ /* 分别向左右子树递归查找 */elemType *p ;if(p = findBTree(bt->left, x)){return p ;}if(p = findBTree(bt->right, x)){return p ;}return NULL ;}}}/* 6.输出二叉树(前序遍历) */void printBTree(struct BTreeNode *bt){/* 树为空时结束递归，否则执行如下操作 */if(bt != NULL){printf("%c ", bt->data); /* 输出根结点的值 */ if(bt->left != NULL || bt->right != NULL){printf("(") ;printBTree(bt->left) ;if(bt->right != NULL){printf(",") ;}printBTree(bt->right) ;printf(")");}}return;}/* 7.清除二叉树，使之变为一棵空树 */void clearBTree(struct BTreeNode* *bt){if(*bt != NULL){clearBTree(&((*bt)->left)) ;clearBTree(&((*bt)->right)) ;free(*bt) ;*bt = NULL ;}return ;}/* 8.前序遍历 */void preOrder(struct BTreeNode *bt){if(bt != NULL){printf("%c ", bt->data) ; /* 访问根结点 */ preOrder(bt->left) ; /* 前序遍历左子树 */ preOrder(bt->right) ; /* 前序遍历右子树 */}return ;}/* 9.中序遍历 */void inOrder(struct BTreeNode *bt){if(bt != NULL){inOrder(bt->left); /* 中序遍历左子树 */printf("%c ", bt->data); /* 访问根结点 */inOrder(bt->right); /* 中序遍历右子树 */}return;}/* 10.后序遍历 */void postOrder(struct BTreeNode *bt){if(bt != NULL){postOrder(bt->left); /* 后序遍历左子树 */postOrder(bt->right); /* 后序遍历右子树 */printf("%c ", bt->data); /* 访问根结点 */}return;}/* 11.按层遍历 */void levelOrder(struct BTreeNode *bt){struct BTreeNode *p;struct BTreeNode *q[QUEUE_MAX_SIZE];int front = 0, rear = 0;/* 将树根指针进队 */if(bt != NULL){rear = (rear + 1) % QUEUE_MAX_SIZE;q[rear] = bt;}while(front != rear){ /* 队列非空 */front = (front + 1) % QUEUE_MAX_SIZE; /* 使队首指针指向队首元素 */ p = q[front];printf("%c ", p->data);/* 若结点存在左孩子，则左孩子结点指针进队 */if(p->left != NULL){rear = (rear + 1) % QUEUE_MAX_SIZE;q[rear] = p->left;}/* 若结点存在右孩子，则右孩子结点指针进队 */if(p->right != NULL){rear = (rear + 1) % QUEUE_MAX_SIZE;q[rear] = p->right;}}return;}/************************************************************************/int main(int argc, char *argv[]){struct BTreeNode *bt ; /* 指向二叉树根结点的指针 */char *b ; /* 用于存入二叉树广义表的字符串 */elemType x, *px ;initBTree(&bt) ;printf("输入二叉树广义表的字符串：\n") ;/* scanf("%s", b); */b = "a(b(c), d(e(f, g), h(, i)))" ; //////其中不在括号中的字符表示的是根节点括号中的分别是左右儿子createBTree(&bt, b) ;if(bt != NULL)printf(" %c ", bt->data) ;printf("以广义表的形式输出：\n") ;printBTree(bt); /* 以广义表的形式输出二叉树 */printf("\n");printf("前序："); /* 前序遍历 */preOrder(bt);printf("\n");printf("中序："); /* 中序遍历 */inOrder(bt);printf("\n");printf("后序："); /* 后序遍历 */postOrder(bt);printf("\n");printf("按层："); /* 按层遍历 */levelOrder(bt);printf("\n");/* 从二叉树中查找一个元素结点 */printf("输入一个待查找的字符：\n");scanf(" %c", &x); /* 格式串中的空格跳过空白字符 */px = findBTree(bt, x);if(px){printf("查找成功：%c\n", *px);}else{printf("查找失败！\n");}printf("二叉树的深度为：");printf("%d\n", BTreeDepth(bt));clearBTree(&bt);return 0;}。