C语言二叉树

判断一棵树是否为满二叉树的算法c语言判断一棵树是否为满二叉树的算法（C语言）满二叉树是一种特殊的二叉树，每个节点要么没有子节点，要么有两个子节点。

判断一棵树是否为满二叉树的算法可以通过以下步骤实现：1. 定义二叉树的数据结构在C语言中，可以使用结构体定义二叉树的节点。

每个节点包含一个数据域和两个指针域，分别指向左子节点和右子节点。

```cstruct TreeNode {int data;struct TreeNode* left;struct TreeNode* right;};```2. 实现判断函数编写一个递归函数，用于判断给定二叉树是否为满二叉树。

函数的输入参数为根节点指针，返回值为布尔类型。

```cint isFullBinaryTree(struct TreeNode* root) {// 如果根节点为空，则返回真if (root == NULL) {return 1;}// 如果只有一个子节点或没有子节点，则返回假if ((root->left == NULL && root->right != NULL) ||(root->left != NULL && root->right == NULL)) {return 0;}// 递归判断左子树和右子树return isFullBinaryTree(root->left) && isFullBinaryTree(root->right);}```3. 测试样例可以编写一些测试样例来验证判断函数的正确性。

例如，下面是一个满二叉树和一个非满二叉树的示例：```cint main() {// 满二叉树struct TreeNode* root1 = (struct TreeNode*)malloc(sizeof(struct TreeNode));root1->data = 1;root1->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));root1->left->data = 2;root1->left->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));root1->left->left->data = 4;root1->left->left->left = NULL;root1->left->left->right = NULL;root1->left->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));root1->left->right->data = 5;root1->left->right->left = NULL;root1->left->right->right = NULL;root1->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));root1->right->data = 3;root1->right->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));root1->right->left->data = 6;root1->right->left->left = NULL;root1->right->left->right = NULL;root1->right->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));root1->right->right->data = 7;root1->right->right->left = NULL;root1->right->right->right = NULL;// 非满二叉树struct TreeNode* root2 = (struct TreeNode*)malloc(sizeof(struct TreeNode));root2->data = 1;root2->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));root2->left->data = 2;root2->left->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));root2->left->left->data = 4;root2->left->left->left = NULL;root2->left->left->right = NULL;root2->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));root2->right->data = 3;root2->right->left = NULL;root2->right->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));root2->right->right->data = 7;root2->right->right->left = NULL;root2->right->right->right = NULL;// 判断是否为满二叉树if (isFullBinaryTree(root1)) {printf("root1是满二叉树\n");} else {printf("root1不是满二叉树\n");}if (isFullBinaryTree(root2)) {printf("root2是满二叉树\n");} else {printf("root2不是满二叉树\n");}return 0;}```运行上述代码，输出结果为：```root1是满二叉树root2不是满二叉树```根据以上算法和示例，我们可以判断一棵树是否为满二叉树。

题目:二叉排序树的实现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语言中，我们可以通过递归算法来实现二叉树的先序遍历。

首先，我们需要定义二叉树的结构体，包括树的节点结构以及创建树的函数。

树的节点结构体定义如下：```ctypedef struct TreeNode {int data;struct TreeNode* left;struct TreeNode* right;} TreeNode;```接下来，我们可以编写递归函数来实现先序遍历。

先序遍历的递归算法如下：```cvoid preorderTraversal(TreeNode* root) {if (root == NULL) {return;}printf("%d ", root->data); // 访问根结点preorderTraversal(root->left); // 递归遍历左子树preorderTraversal(root->right); // 递归遍历右子树}```在这段代码中，我们首先判断根结点是否为空，如果为空则直接返回。

然后，我们先访问根结点的数据，然后递归地对左子树和右子树进行先序遍历。

接下来，我们可以编写一个测试函数来创建二叉树并进行先序遍历：```cint main() {// 创建二叉树TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));root->data = 1;root->left = (TreeNode*)malloc(sizeof(TreeNode));root->left->data = 2;root->left->left = NULL;root->left->right = NULL;root->right = (TreeNode*)malloc(sizeof(TreeNode));root->right->data = 3;root->right->left = NULL;root->right->right = NULL;// 先序遍历二叉树printf("Preorder traversal: ");preorderTraversal(root);return 0;}```在这个测试函数中，我们首先创建了一个简单的二叉树，然后调用先序遍历函数对这棵树进行遍历，并输出遍历结果。

c语言哈夫曼树的构造及编码一、哈夫曼树概述哈夫曼树是一种特殊的二叉树，它的构建基于贪心算法。

它的主要应用是在数据压缩和编码中，可以将频率高的字符用较短的编码表示，从而减小数据存储和传输时所需的空间和时间。

二、哈夫曼树的构造1. 哈夫曼树的定义哈夫曼树是一棵带权路径长度最短的二叉树。

带权路径长度是指所有叶子节点到根节点之间路径长度与其权值乘积之和。

2. 构造步骤(1) 将待编码字符按照出现频率从小到大排序。

(2) 取出两个权值最小的节点作为左右子节点，构建一棵新的二叉树。

(3) 将新构建的二叉树加入到原来排序后队列中。

(4) 重复上述步骤，直到队列只剩下一个节点，该节点即为哈夫曼树的根节点。

3. C语言代码实现以下代码实现了一个简单版哈夫曼树构造函数：```ctypedef struct TreeNode {int weight; // 权重值struct TreeNode *leftChild; // 左子节点指针struct TreeNode *rightChild; // 右子节点指针} TreeNode;// 构造哈夫曼树函数TreeNode* createHuffmanTree(int* weights, int n) {// 根据权值数组构建节点队列，每个节点都是一棵单独的二叉树TreeNode** nodes = (TreeNode**)malloc(sizeof(TreeNode*) * n);for (int i = 0; i < n; i++) {nodes[i] = (TreeNode*)malloc(sizeof(TreeNode));nodes[i]->weight = weights[i];nodes[i]->leftChild = NULL;nodes[i]->rightChild = NULL;}// 构建哈夫曼树while (n > 1) {int minIndex1 = -1, minIndex2 = -1;for (int i = 0; i < n; i++) {if (nodes[i] != NULL) {if (minIndex1 == -1 || nodes[i]->weight < nodes[minIndex1]->weight) {minIndex2 = minIndex1;minIndex1 = i;} else if (minIndex2 == -1 || nodes[i]->weight < nodes[minIndex2]->weight) {minIndex2 = i;}}}TreeNode* newNode =(TreeNode*)malloc(sizeof(TreeNode));newNode->weight = nodes[minIndex1]->weight + nodes[minIndex2]->weight;newNode->leftChild = nodes[minIndex1];newNode->rightChild = nodes[minIndex2];// 将新构建的二叉树加入到原来排序后队列中nodes[minIndex1] = newNode;nodes[minIndex2] = NULL;n--;}return nodes[minIndex1];}```三、哈夫曼编码1. 哈夫曼编码的定义哈夫曼编码是一种前缀编码方式，它将每个字符的编码表示为二进制串。

哈夫曼树的构造c语言代码哈夫曼树是一种特殊的二叉树，常被用于数据压缩中。

它的构造过程非常重要，接下来我将用c语言展示如何构造哈夫曼树。

首先，我们需要定义一个结构体作为节点：```struct Node{int weight;//权重int parent;//父节点在数组中的下标int lchild;//左子节点在数组中的下标int rchild;//右子节点在数组中的下标};```然后，我们需要读入数据，计算每个数据的权重，随后用一个数组存储节点信息：```int n;//数据个数int W[maxn];//存储每个数据的权重Node tree[maxn*2-1];//哈夫曼树```接下来，我们需要编写一个函数用来选择权值最小的两个节点，然后将它们合并成一个节点。

```int select_min(Node*tree,int n){int res=-1;int min=INT_MAX;for(int i=0;i<n;i++){if(tree[i].parent!=-1)continue;//跳过已经合并的节点if(tree[i].weight<min){min=tree[i].weight;res=i;}}return res;}void merge_node(Node*tree,int a,int b,int i){tree[a].parent=i;tree[b].parent=i;tree[i].weight=tree[a].weight+tree[b].weight;tree[i].lchild=a;tree[i].rchild=b;}```接下来，我们就可以开始构造哈夫曼树了。

我们先初始化每个节点，将它们都看成一个独立的树，然后选择最小的两个节点进行合并，直到最后只剩下一个树为止。

```void build_tree(Node*tree,int n,int*W){for(int i=0;i<n;i++){tree[i].weight=W[i];tree[i].parent=-1;tree[i].lchild=-1;tree[i].rchild=-1;}for(int i=n;i<(n<<1)-1;i++) {int a=select_min(tree,i);int b=select_min(tree,i);merge_node(tree,a,b,i);}}```最后，我们可以调用build_tree函数来构造哈夫曼树。

二叉树 c语言在计算机科学领域中，树型数据结构是一种非常重要的数据结构，在实际开发中也得到了广泛的应用。

其中，二叉树又是一种非常常见的树型结构。

二叉树在很多情况下都能够提供更好的算法效率，同时也易于理解和实现，因此我们可以通过通过学习和掌握二叉树的特点以及优点，来更好的应用到实际开发中。

一、二叉树的定义二叉树是一种树型结构，树型结构是由节点构成的。

二叉树与一般的树型结构不同，它的每个节点最多只有两个子节点，分别称为左子树和右子树。

它们可以为空或者不为空，其子节点的数量时不固定且没有任何限制的。

二叉树的定义如下：（1）空树是树的一种特殊的状态。

我们可以把它称为二叉树；（2）若不是空树，那么它就是由一个称为根节点（root）的元素和左右两棵分别称为左子树（left subtree）和右子树（right subtree）的二叉树组成。

二、二叉树的特性（1）每个节点最多只有两个子节点，分别称为左子节点和右子节点；（2）左子树和右子树是二叉树；（3）二叉树没有重复的节点。

三、二叉树的应用二叉树是一种非常实用的数据结构，因为它可以模拟很多实际生活中的情况。

例如，我们可以利用二叉树来对某些数据进行分类和排序。

在二叉树的基础上，我们还可以构造二叉堆、哈夫曼树等更高级的数据结构。

除此之外，二叉树还可以应用到程序设计中。

例如，我们可以构造一个二叉树来表示某个程序的控制流，这个程序在执行时可以沿着二叉树的各个节点进行分支和选择，实现不同的功能。

此外，我们还可以利用二叉树来加快某些算法的执行效率，比如二分查找算法等。

四、二叉树的遍历方式对于二叉树的遍历，有三种基本方式，即前序遍历、中序遍历、后序遍历。

它们的遍历顺序不同，因此也得到了不同的称呼。

下面我们来简要介绍一下这三种遍历方式的特点和应用。

（1）前序遍历前序遍历是指首先访问树的根节点，然后按照从左到右的顺序依次遍历左子树和右子树。

前序遍历的应用非常广泛，可以用于生成表达式树、构造二叉树等等。

# include "stdio.h"# include "stdlib.h"# include "malloc.h"typedef struct Node{char data; //定义根结点struct Node *lchild; //定义左子树struct Node *rchild; //定义右子树}Node,*BiTree;int JianShu(BiTree &T) { //构造二叉链表表示的二叉树T,按先序遍历输入二//叉树中结点的值(一个字符),空格字符表示空树.char e;T=(Node *)malloc(sizeof(Node)); //开辟一个以sizeof(Node)为单位的空间if(!T) //开辟失败exit (-2);fflush(stdin); //清空缓存scanf ("%c",&e);if(e==' ')T=NULL;else {T->data=e; // 生成根结点printf ("请输入%c的左孩子:",e);JianShu(T->lchild); // 构造左子树printf ("请输入%c的右孩子:",e);JianShu(T->rchild); // 构造右子树}return 1;}int DLR_P(BiTree &T) { //先序遍历打印二叉树中所有数据if (T!=NULL) { //非空二叉树printf ("%c ",T->data); //访问TDLR_P(T->lchild); //递归遍历左子树DLR_P(T->rchild); //递归遍历右子树}return 1;}int LDR_P(BiTree &T) { //中序遍历打印二叉树中所有数据if (T!=NULL) { //非空二叉树LDR_P(T->lchild); //递归遍历左子树printf ("%c ",T->data); //访问TLDR_P(T->rchild); //递归遍历右子树}return 1;}int LRD_P(BiTree &T) { //后序遍历打印二叉树中所有数据if (T!=NULL) { //非空二叉树LRD_P(T->lchild); //递归遍历左子树LRD_P(T->rchild); //递归遍历右子树printf ("%c ",T->data); //访问T}return 1;}int DLR_0(BiTree &T,int &s_0) { //用先序遍历求二叉树T中所有叶子总数if (T!=NULL) { //非空二叉树if(!T->lchild&&!T->rchild) { //判断该结点是否为叶子s_0++; //是叶子则计数并打印printf ("%c ",T->data);}DLR_0(T->lchild,s_0); //递归遍历左子树,直到叶子处DLR_0(T->rchild,s_0); //递归遍历右子树,直到叶子处}return s_0;}int DLR_1(BiTree &T,int &s_1) { //用先序遍历求二叉树T中所有1度结点总数if (T!=NULL) { //非空二叉树if(T->lchild&&!T->rchild) { //判断该结点是否为1度结点s_1++; //是1度结点则计数并打印printf ("%c ",T->data);}if(!T->lchild&&T->rchild) { //判断该结点是否为1度结点s_1++; //是1度结点则计数并打印printf ("%c ",T->data);}DLR_1(T->lchild,s_1); //递归遍历左子树,直到1度结点处DLR_1(T->rchild,s_1); //递归遍历右子树,直到1度结点处}return s_1;}int DLR_2(BiTree &T,int &s_2) { //用先序遍历求二叉树T中所有2度结点总数if (T!=NULL) { //非空二叉树if(T->lchild&&T->rchild) { //判断该结点是否为2度结点s_2++; //是2度结点则计数并打印printf ("%c ",T->data);}DLR_2(T->lchild,s_2); //递归遍历左子树,直到2度结点处DLR_2(T->rchild,s_2); //递归遍历右子树,直到2度结点处}return s_2;}int ShenDu(BiTree &T,int l,int &h) { //用递归求二叉树的深度if (T!=NULL) { //非空二叉树l=l+1;if (l>h) h=l;ShenDu(T->lchild,l,h); //递归遍历左子树ShenDu(T->rchild,l,h); //递归遍历右子树}return 1;}int QingKong(BiTree &T) { //清空二叉树if (T!=NULL) {QingKong(T->lchild); //遍历清空左子树free(T->lchild);QingKong(T->rchild); //遍历清空右子树free(T->rchild);}return 1;}int main () { //主函数int i,a=0;Node *T; //定义一个二叉树Twhile(1) {system("cls");printf("\t|===========================================================|\t\n");printf ("\t| |\t\n");printf ("\t| 二叉树的链式存储|\t\n");printf ("\t| |\t\n");printf("\t|===========================================================|\t\n");printf ("\n\t【1】建立二叉树及先序输入!\t 【2】遍历二叉树打印!\n");printf ("\n\t【3】打印各结点并统计! \t 【4】求二叉树的深度!\n");printf ("\n\t【5】清空二叉树!\t\t 【0】退出程序!\n");system("color F0");printf ("\n\n\t\t\t请输入你的选择:"); //输入选择的功能序号scanf ("%d",&i);switch(i) {case 1: //建立二叉树T并输入数据printf ("请输入二叉树T的根:");JianShu(T);a=1;system("pause");break;case 2: //遍历打印二叉树中所有数据if(a==1) {if(T!=NULL) { //非空二叉树Tprintf ("先序遍历打印结果:"); //执行先序遍历并打印DLR_P(T);printf ("\n\n中序遍历打印结果:"); //执行中序遍历并打印LDR_P(T);printf ("\n\n后序遍历打印结果:"); //执行后序遍历并打印LRD_P(T);printf ("\n");}elseprintf ("二叉树T为空树!\n");}else //未建立二叉树printf ("未建立二叉树!\n");system("pause");break;case 3: //先序遍历打印二叉树中0度1度2度结点if(a==1) {if(T!=NULL) { //非空二叉树Tint s_0=0,s_1=0,s_2=0;printf ("二叉树中叶子:");DLR_0(T,s_0); //执行先序遍历打印叶子并统计printf ("共有%d个叶子!\n",s_0);printf ("\n二叉树中1度结点:");DLR_1(T,s_1); //执行先序遍历打印1度结点并统计printf ("共有%d个1度结点!\n",s_1);printf ("\n二叉树中2度结点:");DLR_2(T,s_2); //执行先序遍历打印2度结点并统计printf ("共有%d个2度结点!\n",s_2);}elseprintf ("二叉树T为空树!\n");}else //未建立二叉树printf ("未建立二叉树!\n");system("pause");break;case 4: //用递归求二叉树的深度if(a==1) {if(T!=NULL) { //非空二叉树Tint l=0,h=0;ShenDu(T,l,h);printf ("二叉树的深度为%d.\n",h);}elseprintf ("二叉树T为空树!\n");}else //未建立二叉树printf ("未建立二叉树!\n");system("pause");break;case 5: //清空二叉树if(a==1) {if(T!=NULL) { //非空二叉树QingKong(T); //清空二叉树T=NULL;printf ("二叉树已清空!\n");}elseprintf ("二叉树T为空树,既不用清空!\n");}else //未建立二叉树printf ("未建立二叉树,既不用清空!\n");system("pause");break;case 0: //退出程序printf ("退出程序!\n");return 1;default: //重新输入选择的功能序号printf ("输入有误,请重新输入!\n");system("pause");break;}}}。

交换二叉树每个节点的左孩子和右孩子的类c算法交换二叉树每个节点的左孩子和右孩子的类c算法在计算机科学领域中，二叉树是一种常见的数据结构，它在树状结构中拥有广泛的应用。

而在二叉树的操作中，交换每个节点的左孩子和右孩子是一种常见的需求。

在本文中，我将为大家介绍一种用C语言实现的算法，用于交换二叉树每个节点的左孩子和右孩子。

在进行算法设计之前，我们首先需要了解二叉树的基本概念。

二叉树是一种树状数据结构，其中每个节点最多有两个子节点，分别称为左孩子和右孩子。

在交换二叉树的左右孩子时，我们需要递归地遍历每个节点，并交换其左右孩子的位置。

接下来，我将用C语言实现一个函数，用于交换二叉树每个节点的左孩子和右孩子。

以下是该函数的代码实现：```c#include <stdio.h>#include <stdlib.h>struct TreeNode {int val;struct TreeNode *left;struct TreeNode *right;};void swapChildren(struct TreeNode* root) {if (root == NULL) {return;}// 递归交换左右孩子的位置struct TreeNode* temp = root->left;root->left = root->right;root->right = temp;swapChildren(root->left);swapChildren(root->right);}```在这段代码中，我们首先定义了一个名为TreeNode的结构体，其中包含一个整型变量val和两个指向左右孩子的指针。

我们定义了一个名为swapChildren的函数，该函数接受一个指向根节点的指针作为参数，用于递归地交换每个节点的左右孩子。

在函数内部，我们首先判断当前节点是否为空，如果为空则直接返回；否则，我们交换当前节点的左右孩子，并递归地调用swapChildren函数来交换其左右子树。

浅析一种二叉树非递归遍历算法的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语言编写二叉树的建立与遍历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显示用户界面，这时候就能够看到结果了。