d changeLR(BiTree root)\n{\n//请在此处填写代码， 完成二叉树左右子树互换\n/********** Begin **********/

好的，这是一道关于二叉树操作的题目，需要将二叉树的左右子树互换。以下是代码实现：

void changeLR(BiTree root)
{
    if(root == NULL) return;
    BiTree temp = root->lchild;
    root->lchild = root->rchild;
    root->rchild = temp;
    changeLR(root->lchild);
    changeLR(root->rchild);
}

以上代码中，我们首先判断当前节点是否为空，如果为空则直接返回。如果当前节点不为空，则将其左右子树互换。最后递归对左右子树进行同样的操作。

相关问题

完善代码：#include <stdio.h> #include <malloc.h> #include <conio.h> typedef int ElemType; typedef struct BiTreeNode { ElemType data; struct BiTreeNode *lchild, *rchild; } BiTreeNode,*BiTree; void Visit(BiTree bt) { printf("%d ",bt->data); } int max(int x,int y) { if (x>y) return x; else return y; } //二叉树的先序遍历算法 void PreOrder(BiTree bt) /* bt为指向根结点的指针*/ { if (bt) /*如果bt为空，结束*/ { Visit (bt ); /*访问根结点*/ PreOrder (bt -> lchild); /*先序遍历左子树*/ PreOrder (bt -> rchild); /*先序遍历右子树*/ } } //二叉树的中序遍历递归算法 void InOrder(BiTree bt)/* bt为指向二叉树根结点的指针*/ { } //二叉树的后序遍历递归算法 void PostOrder(BiTree bt) /* bt为指向二叉树根结点的指针*/ { } //结合“扩展先序遍历序列”创建二叉树,递归 BiTree CreateBiTree(ElemType s[]) { BiTree bt; static int i=0; ElemType c = s[i++]; if( c== -1) bt = NULL; /* 创建空树 */ else { bt = (BiTree)malloc(sizeof(BiTreeNode)); bt->data = c; /* 创建根结点 */ bt->lchild = CreateBiTree(s); /* 创建左子树 */ bt->rchild = CreateBiTree(s); /* 创建右子树 */ } return bt; } //根据先序序列、中序序列建立二叉树，递归 BiTree PreInOrder(ElemType preord[],ElemType inord[],int i,int j,int k,int h) { BiTree t; //添加代码 return t; } BiTree CreateBiTree_PreIn(ElemType preord[],ElemType inord[],int n) { BiTree root; if (n<=0) root=NULL; else root=PreInOrder(preord,inord,0,n-1,0,n-1); return root; } //统计叶结点个数 int BitreeLeaf ( BiTree bt ) { if ( bt == NULL ) return 0 ; /* 空树，叶子数为0 */ if ( bt->lchild ==NULL&& bt->rchild == NULL) return 1 ; /*只有一个根结点，叶子数为1*/ return ( BitreeLeaf( bt -> lchild ) + BitreeLeaf ( bt -> rchild )) ; } //统计二叉树的深度 int BitreeDepth ( BiTree bt ) { int d = 0,depthL, depthR; /*depthL和depthR分别为左、右子树的深度*/ if ( bt == NULL ) return 0 ; /*空树，深度为0 */ if ( bt -> lchild ==NULL && bt -> rchild == NULL) return 1; /*叶子结点，深度为1 */ depthL = BitreeDepth ( bt -> lchild ) ; /*左子树深度 */ depthR = BitreeDepth ( bt -> rchild ) ; /*右子树深度 */ d = max (dept

hL, depthR) + 1; /*当前结点深度*/ return d ; } int main() { ElemType s1[] = {1,2,-1,-1,3,-1,-1}; BiTree bt1; bt1 = CreateBiTree(s1); printf("二叉树的先序遍历："); PreOrder(bt1); printf("\n"); printf("二叉树的中序遍历："); InOrder(bt1); printf("\n"); printf("二叉树的后序遍历："); PostOrder(bt1); printf("\n"); ElemType pre[] = {1,2,3}; ElemType in[] = {2,1,3}; BiTree bt2; bt2 = CreateBiTree_PreIn(pre,in,3); printf("根据先序序列、中序序列建立的二叉树的先序遍历："); PreOrder(bt2); printf("\n"); printf("根据先序序列、中序序列建立的二叉树的中序遍历："); InOrder(bt2); printf("\n"); printf("根据先序序列、中序序列建立的二叉树的后序遍历："); PostOrder(bt2); printf("\n"); printf("二叉树的叶子结点个数：%d\n",BitreeLeaf(bt2)); printf("二叉树的深度：%d\n",BitreeDepth(bt2)); return 0; }

注释已经比较详细了，只需要实现InOrder和PostOrder函数即可。InOrder函数中需要先中序遍历左子树，然后访问根结点，最后中序遍历右子树。PostOrder函数中需要先后序遍历左子树，然后后序遍历右子树，最后访问根结点。完整代码如下：

//二叉链表的结构定义 typedef char ElemType;//元素类型为字符类型 typedef struct BTNode { ElemType data; struct BTNode *lchild, *rchild; }BTNode; typedef struct BTNode bitree; /*函数声明从此处开始*/ //以递归方式创建二叉树（需扩展）,如输入：ABD##E##C#FHJ##K##I## bitree * CreateBTree1(); //以递归方式创建二叉树（需扩展）,如输入：ABD##E##C#FHJ##K##I## void CreateBTree2(bitree *&root); //销毁二叉树：释放动态分配的空间 void DestroyBTree(bitree *root); /*函数声明到此处结束*/ /*函数定义从此处开始*/ //以递归方式创建二叉树（需扩展）,如输入：ABD##E##C#FHJ##K##I## bitree * CreateBTree1() { bitree *root ;char ch; ch=getchar(); if (ch == '#') root = NULL; else { root=(bitree*)malloc(sizeof(bitree)); root->data=ch; root->lchild = NULL; root->rchild = NULL; root->lchild =CreateBTree1(); root->rchild= CreateBTree1(); } return root; } //以递归方式创建二叉树（需扩展）,如输入：ABD##E##C#FHJ##K##I## void CreateBTree2(bitree *&root) { char ch; ch=getchar(); if (ch == '#') root = NULL; else { root=(bitree*)malloc(sizeof(bitree)); root->data=ch; root->lchild = NULL; root->rchild = NULL; CreateBTree2(root->lchild); CreateBTree2(root->rchild); } } //销毁二叉树：释放动态分配的空间 void DestroyBTree(bitree *root) { if( root != NULL) { if (root->lchild != NULL) DestroyBTree(root->lchild); if (root->rchild != NULL) DestroyBTree(root->rchild); free(root); } }

CEG###FH##I##，表示根节点为A，A的左子树为B的子树，B的左子树为空，右子树为D的子树，D的左右子树为空，A的右子树为C的子树，C的左子树为空，右子树为E的子树，E的左右子树为空，C的右子树为F的子树，F的左子树为空，右子树为空，A到F中间不含节点（即空节点记为#） bitree *CreatBTree(); //层次遍历输出二叉树 void LevelOrder(bitree *root); //前序遍历递归版 void PreOrder_Traversal(bitree *root); //前序遍历非递归版 void Pre_Order_Traversal(bitree *root); //中序遍历递归版 void InOrder_Traversal(bitree *root); //中序遍历非递归版 void In_Order_Traversal(bitree *root); //后序遍历递归版 void PostOrder_Traversal(bitree *root); //后序遍历非递归版 void Post_Order_Traversal(bitree *root); //计算二叉树的深度 int Tree_Depth(bitree *root); //统计二叉树中叶子节点的个数 int Leaf_Count(bitree *root); //统计二叉树中节点的个数 int Node_Count(bitree *root);

以上是二叉链表的结构定义和一些常用操作函数的函数声明。其中包括以递归和非递归方式实现的前序、中序、后序遍历函数、层次遍历函数、计算二叉树深度函数、统计叶子节点个数函数和统计节点个数函数。其中，以递归方式实现的遍历函数通常使用较简单，但非递归方式实现的遍历函数能够充分发挥栈的作用，具有一定的优势。-------------------------------------------------------------------------------------------------------------------------------------------------------------

English version:

The structure definition of binary linked list is shown below:

typedef char ElemType; //Element type is character

typedef struct BTNode {
ElemType data;
struct BTNode *lchild, *rchild;
} BTNode;

typedef struct BTNode bitree;

The following functions are included in the program:

bitree *CreatBTree(); //create binary tree recursively (to be expanded)
void LevelOrder(bitree *root); //traverse binary tree in level order
void PreOrder_Traversal(bitree *root); //preorder traversal recursively
void Pre_Order_Traversal(bitree *root);//preorder traversal non-recursively
void InOrder_Traversal(bitree *root);//inorder traversal recursively
void In_Order_Traversal(bitree *root);//inorder traversal non-recursively
void PostOrder_Traversal(bitree *root);//postorder traversal recursively
void Post_Order_Traversal(bitree *root);//postorder traversal non-recursively
int Tree_Depth(bitree *root);//calculate the depth of binary tree
int Leaf_Count(bitree *root);//count the number of leaf nodes in binary tree
int Node_Count(bitree *root);//count the number of nodes in binary tree

The above functions include recursive and non-recursive versions of preorder, inorder, and postorder traversal functions, level order traversal function, function to calculate the depth of the binary tree, function to count the number of leaf nodes, and function to count the number of nodes. Recursive traversal functions are usually simpler to implement, but non-recursive traversal functions can fully utilize the stack and have certain advantages.