13518219792
//二叉树结点类型为字符型的情况
目前创新互联公司已为上1000+的企业提供了网站建设、域名、虚拟空间、网站托管运营、企业网站设计、康马网站维护等服务，公司将坚持客户导向、应用为本的策略，正道将秉承"和谐、参与、激情"的文化，与客户和合作伙伴齐心协力一起成长，共同发展。
#include stdio.h
#include stdlib.h
#include string.h
#define null 0
#define MaxSize 1024
typedef struct tree
{ /*声明树的结构*/
struct tree *left; /*存放左子树的指针*/
struct tree *right; /*存放右子树的指针*/
char data; /*存放节点的内容*/
} treenode, * b_tree; /*声明二叉树的链表*/
b_tree Q[MaxSize];
/*建立二叉树，按完全二叉树的层次遍历序列输入*/
b_tree createbtree()
{
char ch;
int front,rear;
b_tree root,s;
root=NULL;
front=1;rear=0;
ch=getchar();
getchar();
while(ch!='?')
{
s=NULL;
if(ch!='.')
{
s=(b_tree)malloc(sizeof(treenode));
s-data=ch;
s-left=NULL;
s-right=NULL;
}
rear++;
Q[rear]=s;
if(rear==1)
root=s;
else
{
if(sQ[front])
if(rear%2==0)
Q[front]-left=s;
else
Q[front]-right=s;
if(rear%2==1)
front++;
}
ch=getchar();
getchar();
}
return root;
}
/*先序遍历打印二叉排序树*/
void preorder_btree(b_tree root)
{
b_tree p=root;
if(p!=null)
{
printf("%3c",p-data);
preorder_btree(p-left);
preorder_btree(p-right);
}
}
/* 中序遍历打印二叉排序树*/
void inorder_btree(b_tree root)
{
b_tree p=root;
if(p!=null){
inorder_btree(p-left );
printf("%3c",p-data );
inorder_btree(p-right );
}
}
/*后序遍历打印二叉排序树*/
void postorder_btree(b_tree root)
{
b_tree p=root;
if(p!=null)
{
postorder_btree(p-left );
postorder_btree(p-right );
printf("%3c",p-data );
}
}
/*求树的高度*/
int treedepth(b_tree bt)
{
int hl,hr,max;
if(bt!=null)
{
hl=treedepth(bt-left);
hr=treedepth(bt-right);
max=(hlhr)?hl:hr;
return (max+1);
}
else
return 0;
}
int count=0;
/*求叶子结点总数*/
int leafcount(b_tree bt)
{
if(bt!=null)
{
leafcount(bt-left);
leafcount(bt-right);
if(bt-left==nullbt-right==null)
count++;
}
return count;
}
void paintleaf(b_tree bt)
{
if(bt!=null)
{
if(bt-left==nullbt-right==null)
printf("%3c",bt-data);
paintleaf(bt-left);
paintleaf(bt-right);
}
}
typedef b_tree ElemType ;
int main()
{
char nodelist[MaxSize];
int len,flag;
char cmd;
b_tree root;
do
{
printf(" 输入c......选择创建一棵二叉排序树\n");
printf(" 输入a......将结束本程序\n\n");
flag=0;
do
{
if(flag!=0)
printf("选择操作错误！请重新选择！\n");
fflush(stdin);
scanf("%c",cmd);
flag++;
}while(cmd!='c'cmd!='a');
if(cmd=='c')
{
printf("请输入那你所要创建的二叉树的结点的值,以'？'结束）：\n");
getchar();
root=createbtree();
do
{
flag=0;
printf("\n\n 请选择你要对这棵二叉树所做的操作:\n\n");
printf(" x......先序遍历\n");
printf(" z......中序遍历\n");
printf(" h......后序遍历\n");
printf(" b......层次遍历\n");
printf(" d......求二叉树的深度\n");
printf(" y......求叶子总数并输出各叶子结点\n");
printf(" q......结束操作\n\n");
do
{
if(flag!=0)
printf("选择操作错误！请重新选择！\n");
fflush(stdin);
scanf("%c",cmd);
flag++;
}while(cmd!='x'cmd!='z'cmd!='h'cmd!='b'cmd!='d'cmd!='y'cmd!='j'cmd!='q');
switch(cmd)
{
case 'x':
printf("\n先序遍历开始:\n");
preorder_btree(root);
printf("\n先序遍历结束\n\n");
break;
case 'z':
printf("\n中序遍历开始:\n");
inorder_btree(root);
printf("\n中序遍历结束\n\n");
break;
case 'h':
printf("\n后序遍历开始:\n");
postorder_btree(root);
printf("\n后序遍历结束\n\n");
break;
case 'd':
printf("\n这棵二叉树的高度：\n%d\n\n",treedepth(root));
break;
case 'y':
printf("\n这棵二叉树的叶子结点为：\n");
paintleaf(root);
printf("\n");
count=0;
count=leafcount(root);
printf("\n这棵二叉树的叶子总数为:\n%d\n\n",count);
count=0;
break;
}
}while(cmd!='q'cmd!='Q');
}
}while(cmd!='a'cmd!='A');
printf("****谢谢使用！欢迎指正！****\n\n");
return 0;
}
// 创建二叉树,请输入节点的总数量: 7
// 请连续输入7个节点的数据: 4 2 6 1 3 5 7
// 前序遍历序列: 4 2 1 3 6 5 7
// 中序遍历序列: 1 2 3 4 5 6 7
// 后序遍历序列: 1 3 2 5 7 6 4
// 二叉树的节点一共有7个,度为1的节点有0个,度为2的节点有3个,
// 叶子节点有4个,数据值的最大值是7,最小值是1
//
// 对应的二叉树:
//
// 4
// / \
// 2 6
// / \ / \
// 1 3 5 7
#include "stdio.h"
#include "stdlib.h"
struct Tree
{
int data;
struct Tree *left;
struct Tree *right;
};
typedef struct Tree TreeNode;
typedef TreeNode *Bitree;
typedef struct stack_node //栈的结构体
{
Bitree bt;
struct stack_node *next;
} stack_list, *stack_link;
Bitree insertNode(Bitree root,int data) //插入结点
{
Bitree newnode;
Bitree current;
Bitree back;
newnode=(Bitree)malloc(sizeof(TreeNode));
if(newnode==NULL)
{
printf("\n动态分配内存出错.\n");
exit(1);
}
newnode-data=data;
newnode-left=NULL;
newnode-right=NULL;
if(root==NULL)
{
return newnode;
}
else
{
current=root;
while(current!=NULL)
{
back=current;
if(current-data data)
current=current-left;
else
current=current-right;
}
if(back-data data)
back-left=newnode;
else
back-right=newnode;
}
return root;
}
Bitree createTree() //创建二叉树(非递归)
{
Bitree root=NULL;
int len;
int data;
int i;
printf("创建二叉树,请输入节点的总数量: ");
scanf("%d",len);
printf("请连续输入%d个节点的数据: ",len);
for(i=0;ilen;i++)
{
scanf("%d",data);
root=insertNode(root,data);
}
return root;
}
void preOrder(Bitree ptr) //先序遍历(递归法)
{
if(ptr!=NULL)
{
printf("%d ",ptr-data);
preOrder(ptr-left);
preOrder(ptr-right);
}
}
void inOrder(Bitree ptr) //中序遍历(递归法)
{
if(ptr!=NULL)
{
inOrder(ptr-left);
printf("%d ",ptr-data);
inOrder(ptr-right);
}
}
void postOrder(Bitree ptr) //后序遍历(递归法)
{
if(ptr!=NULL)
{
postOrder(ptr-left);
postOrder(ptr-right);
printf("%d ",ptr-data);
}
}
//检查[栈]是否是空
int isEmpty(stack_link stack)
{
if(stack == NULL)
{
return 1;
}
else
{
return 0;
}
}
//入栈
stack_link push(stack_link stack,Bitree bt)
{
stack_link new_node;
new_node=(stack_link)malloc(sizeof(stack_list));
if(!new_node)
{
return NULL;
}
new_node-bt=bt;
new_node-next=stack;
stack=new_node;
return stack;
}
//出栈
stack_link pop(stack_link stack,Bitree *bt)
{
stack_link top;
if(isEmpty(stack))
{
*bt = NULL;
return NULL;
}
top=stack;
*bt=top-bt;
stack=top-next;
free(top);
return stack;
}
//统计节点(非递归)
void reportByStack(Bitree bt,int *pTotal,int *pCount0,int *pCount1,
int *pCount2,int *pMaxValue,int *pMinValue)
{
Bitree p=NULL;
stack_link oneStack=NULL;
int total=0;
int count0=0,count1=0,count2=0;
int maxValue=0,minValue=0;
if(bt == NULL)
{
return;
}
p=bt; //当前二叉树的节点
minValue=p-data;
maxValue=minValue;
while(p != NULL)
{
if(minValue p-data)
{
minValue = p-data;
}
if(maxValue p-data)
{
maxValue = p-data;
}
total++; //total=count0+count1+count2
if(p-right == NULL p-left == NULL) //叶子
{
count0++;
}
else if(p-right != NULL p-left != NULL) //度2
{
count2++;
}
else //度1
{
count1++;
}
if(p-right != NULL) //如果有右子树,马上入栈
{
oneStack=push(oneStack,p-right);
}
if(p-left != NULL) //如果有左子树,设为当前节点
{
p=p-left;
}
else
{
oneStack=pop(oneStack,p);
if(p == NULL)
{
break;
}
}
}
*pTotal=total;
*pCount0=count0;
*pCount1=count1;
*pCount2=count2;
*pMaxValue=maxValue;
*pMinValue=minValue;
}
int main()
{
Bitree root=NULL;
int total=0;
int count0=0,count1=0,count2=0;
int maxValue=0,minValue=0;
root=createTree(); //创建二叉树
printf("\n前序遍历序列: ");
preOrder(root);
printf("\n中序遍历序列: ");
inOrder(root);
printf("\n后序遍历序列: ");
postOrder(root);
//统计节点(非递归)
reportByStack(root,total,count0,count1,count2,maxValue,minValue);
printf("\n二叉树的节点一共有%d个,度为1的节点有%d个,度为2的节点有%d个,\n",
total,count1,count2);
printf("叶子节点有%d个,数据值的最大值是%d,最小值是%d",
count0,maxValue,minValue);
printf("\n");
return 0;
}
楼主你好
具体代码如下：
#includestdio.h
#includestdlib.h
#define MAX 40
typedef struct node//二叉树结点定义
{
char data;
struct node *lChild;//左孩子
struct node *rChild;//右孩子
}BTNode;
//*************************************二叉树操作***************************************
void Initial_BT(BTNode * b)
{
b=NULL;
}
void Creat_BT(BTNode * b)//创建二叉树
{
BTNode *St[MAX];//用栈辅助实现二叉树的建立
BTNode *p=NULL;
b=NULL;
int top=-1;//栈指针
int k;//k为左右孩子标示(1为左孩子、2为右孩子)
char ch;
printf("Enter the binary tree:\n");
ch=getchar();
while(ch!='\n')
{
switch(ch)
{
case '('://左孩子
top++;
St[top]=p;
k=1;
break;
case ')':
top--;
break;
case ','://右孩子
k=2;
break;
default:
p=(BTNode *)malloc(sizeof(BTNode));
p-data=ch;
p-lChild=p-rChild=NULL;
if(!b)//如果为根节点
b=p;
else
{
switch(k)
{
case 1:
St[top]-lChild=p;
break;
case 2:
St[top]-rChild=p;
break;
}
}
}
ch=getchar();//继续读入数据
}
}
void InOrder(BTNode *b)//中序遍历
{
if(b)
{
InOrder(b-lChild);
printf("%c",b-data);
InOrder(b-rChild);
}
}
void PostOrder(BTNode *b)//后序遍历
{
if(b)
{
PostOrder(b-lChild);
PostOrder(b-rChild);
printf("%c",b-data);
}
}
int Leaf_Sum(BTNode *b)
{
if(!b)
return 0;
else if(b-lChild == NULL b-rChild == NULL)
return 1;
else
return Leaf_Sum(b-lChild)+Leaf_Sum(b-rChild);
}
void Start()
{
BTNode *b;//二叉树
char choice;
b=(BTNode *)malloc(sizeof(BTNode));
Initial_BT(b);
GOTO:system("cls");
printf("\t\t1.创建二叉树.\n"
"\t\t2.中序遍历.\n"
"\t\t3.后序遍历.\n"
"\t\t4.叶子结点个数.\n"
"\t\t5.退出.\n");
printf("输入你的选择:");
GOTO1:choice=getchar();
switch(choice)
{
case '1':
getchar();
Creat_BT(b);
system("pause");
goto GOTO;
case '2':
InOrder(b);
printf("\n");
system("pause");
getchar();
goto GOTO;
case '3':
PostOrder(b);
printf("\n");
system("pause");
getchar();
goto GOTO;
case '4':
printf("共有%d个叶子结点\n",Leaf_Sum(b));
system("pause");
getchar();
goto GOTO;
case '5':
system("pause");
break;
default:
printf("输入错误!\n"
"重新输入:");
goto GOTO1;
}
}
int main()
{
Start();
return 0;
}
希望能帮助你哈
//这个题目挺有意思的，很喜欢，你看看我这个咋样啊？
#includestdio.h
#includemalloc.h
typedef
char
elemtype
;
typedef
struct
node
{
elemtype
data
;
struct
node
*lchild
;
struct
node
*rchild
;
}btree,*pbtree
;
//先序创建树
void
createbtree(pbtree
*t)
//此处参数应该用指针的指针，应给它要改变指向二叉树根的那个指针
{
char
ch
;
ch=getchar();
getchar();
//得到回车按那个字符
if(ch
=='
')
//输入空字符时要打空格
{
(*t)
=
null
;
return
;
}
else
{
if(
!(
(*t)
=
(pbtree)
malloc(sizeof(btree))
)
)
return
;
(*t)-data
=
ch
;
createbtree(
(*t)-lchild
);
createbtree(
(*t)-rchild
);
}
}
void
btreeprint(btree
*tr,int
n)
//逆时针旋转90°打印二叉树，n为缩进层数，初始值为0
{
int
i;
if(tr
==
null)
return;
btreeprint(tr-rchild,n+1);
for(i
=
0;in;i++)
printf("
");
if(n
=
0)
{
printf("--");
printf("%c\n",tr-data);
}
btreeprint(tr-lchild,n+1);
}
void
main()
{
pbtree
btree
;
createbtree(btree);
btreeprint(btree,0);
}
输入举例：建立以a为根b、c分别为左右子树的二叉树！输入格式为：
a
回车！
b
回车！
空格
回车！
空格
回车！
c
回车！
空格
回车！
空格
回车！
在二叉树中有一种平衡二叉树，通过平衡算法可以让二叉树两边的节点平均分布，这样就能让所有的索引查找都在一个近似的时间内完成。而MySQL这类数据库采用了二叉树的升级版B+Tree的形式，每个节点有三个支叶，不过其算法原理仍然是平衡树的原理。
#includestdio.h
#includestdio.h
#includemalloc.h
#include"c6_2.h"
#includestdlib.h#define TRUE 1
#define NULL 0
#define FALSE 0
#define ERROR 0
#define WRONG 0
#define OK 1
#define OVERFLOW 0typedef int TElemType;
typedef int Status;//二叉树结构体
typedef struct BiTNode
{ TElemType data;//结点的值
BiTNode *lchild,*rchild;
}BiTNode,*BiTree;//队列结构体
typedef BiTree QElemType;
typedef struct QNode
{ QElemType data;
QNode *next;
}*QueuePtr;struct LinkQueue
{ QueuePtr front,rear;//队头，队尾指针
};#define ClearBiTree DestoryBiTree//清空二叉树的操作和销毁二叉树的操作一样
void InitBiTree(BiTree T)
{ T=NULL;
}
void DestroyBiTree(BiTree T)
{ //销毁二叉树
if(T)
{ DestroyBiTree(T-lchild);//销毁左子树
DestroyBiTree(T-rchild);//销毁右子树
free(T);
T=NULL;
}
}
void PreOrderTraverse(BiTree T,void(*visit)(TElemType))
{//先序遍历二叉树
if(T)
{ visit(T-data);
PreOrderTraverse(T-lchild,visit);
PreOrderTraverse(T-rchild,visit);
}
}
void InOrderTraverse(BiTree T,void(*visit)(TElemType))
{ //中序遍历二叉树
if(T)
{ InOrderTraverse(T-lchild,visit);
visit(T-data);
InOrderTraverse(T-rchild,visit);
}
}
void PostOrderTraverse(BiTree T,void(*visit)(TElemType))
{ //后序遍历二叉树
if(T)
{ PostOrderTraverse(T-lchild,visit);
PostOrderTraverse(T-rchild,visit);
visit(T-data);
}
}
Status BiTreeEmpty(BiTree T)
{ //判断二叉树是否为空
if(T)
return FALSE;
else
return TRUE;
}
int BiTreeDepth(BiTree T)//返回T的深度
{ int i,j;
if(!T)
return 0;
i=BiTreeDepth(T-lchild);//i为左孩子的深度
j=BiTreeDepth(T-rchild);//j为右孩子的深度
return ij?i+1:j+1;
}
TElemType Root(BiTree T)
{ //返回二叉树的根结点
if(BiTreeEmpty(T))
return NULL;
else
return T-data;
}
TElemType Value(BiTree p)
{//返回P所指结点的值
return p-data;
}
void Assign(BiTree p,TElemType value)
{ //给P的结点赋新值
p-data=value;
}BiTree Point(BiTree T,TElemType s)//返回二叉树T中指向元素值为S的结点指针
{ LinkQueue q;
QElemType a;
if(T)
{ InitQueue(q);//初始化队列
EnQueue(q,T);//根指针入队
while(!QueueEmpty(q))//队不空
{ DeQueue(q,a);//出队，队列元素赋给e
if(a-data==s)//a所指结点为的值为s
return a;
if(a-lchild)//有左孩子
EnQueue(q,a-lchild);//入队左孩子
if(a-rchild)//有右孩子
EnQueue(q,a-rchild);//入队右孩子
}
}
return NULL;
}
TElemType LeftChild(BiTree T,TElemType e)
{//返回e的左孩子
BiTree a;
if(T)
{ a=Point(T,e);//a是指向结点e的指针
if(aa-lchild)
return a-lchild-data;
}
return NULL;
}
TElemType RightChild(BiTree T,TElemType e)
{ BiTree a;
if(T)
{ a=Point(T,e);//a是指向结点e的指针
if(aa-rchild)//T中存在结点e并且e存在右孩子
return a-rchild-data;
}
return NULL;
}
Status DeleteChild(BiTree p,int LR)
{ if(p)
{ if(LR==0)
DestroyBiTree(p-lchild);
else
DestroyBiTree(p-rchild);
return OK;
}
return ERROR;
}void visit(TElemType e)
{ printf("%d",e);
}
void LevelOrderTraverse(BiTree T,void(*visit)(TElemType))
{//层序遍历
LinkQueue q;
QElemType a;
if(T)
{ InitQueue(q);//初始化队列
EnQueue(q,T);//根指针入队
while(!QueueEmpty(q))
{ DeQueue(q,a);//出队元素，赋给a
visit(a-data);//访问a所指结点
if(a-lchild!=NULL)
EnQueue(q,a-lchild);
if(a-rchild!=NULL)
EnQueue(q,a-rchild);
}
}
}
void CreateBiTree(BiTree T)
{ TElemType ch;scanf("%d",ch);//输入结点的值
if(ch==0)//结点为空
T=NULL;
else
{T=(BiTree)malloc(sizeof(BiTNode));br//生成根结点brif(!T)brexit(OVERFLOW);brT-data=ch;//将值赋给T所指结点/ppCreateBiTree(T-lchild);//递归构造左子树brCreateBiTree(T-rchild);br} } TElemType Parent(BiTree T,TElemType e)
{//返回双亲
LinkQueue q;
QElemType a;
if(T)
{ InitQueue(q);
EnQueue(q,T);//树根入队列
while(!QueueEmpty(q))//队不空
{DeQueue(q,a);//出队，队列元素赋给abr if(a-lchilda-lchild-data==e||a-rchilda-rchild-data==e)//找到ebr return a-data;br elsebr { if(a-lchild)br EnQueue(q,a-lchild);//入队列左孩子br if(a-rchild)br EnQueue(q,a-rchild);//入队列右孩子br }
}
}
return NULL;
}
TElemType LeftSibling(BiTree T,TElemType e)
{ //返回左兄弟
TElemType a;
BiTree p;
if(T)
{ a=Parent(T,e);//a为e的双亲
if(a!=NULL)
{ p=Point(T,a);//p指向结点a的指针
if(p-lchildp-rchildp-rchild-data==e)//p存在左右孩子而且右孩子是e
return p-lchild-data;
}
}
return NULL;
}
TElemType RightSibling(BiTree T,TElemType e)
{ //返回右孩子
TElemType a;
BiTree p;
if(T)
{ a=Parent(T,e);//a为e的双亲
if(a!=NULL)
{ p=Point(T,a);//p为指向结点的a的指针
if(p-lchildp-rchildp-lchild-data==e)
return p-lchild-data;
}
}
return NULL;
}
Status InsertChild(BiTree p,int LR,BiTree c)
{ //根据LR为0或1，插入C为T中P所指结点的左或右子树，P所结点的原有左或右子树则成为C的右子树
if(p)
{ if(LR==0)//把二叉树C插入P所指结点的子树
{ c-rchild=p-lchild;//p所结点的原有左子树成为C的右子树
p-lchild=c;//二叉树成为P的左子树
}
else{ c-rchild=p-rchild;//p指结点的原有右子树成为C的右子树
p-rchild=c;
}
return OK;
}
return ERROR;
}
//队列操作
void InitQueue(LinkQueue Q)
{//初始化一个队列
Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
if(!Q.front)//生成头结点失败
exit(OVERFLOW);
Q.front-next=NULL;
}
Status QueueEmpty(LinkQueue Q)
{ //判断队列是否为空
if(Q.front-next==NULL)
return TRUE;
else return FALSE;
}void EnQueue(LinkQueue Q,QElemType e)
{ //插入元素e为队列Q的新的队尾元素
QueuePtr p;
p=(QueuePtr)malloc(sizeof(QNode));
//动态生成新结点
if(!p)
exit(OVERFLOW);
p-data=e;//将e的值赋给新结点
p-next=NULL;//新结点的指针为空
Q.rear-next=p;//原队尾结点的指针域为指向新结点
Q.rear=p;//尾指针指向新结点
}
Status DeQueue(LinkQueue Q,QElemType e)
{ //若队列不为空，删除Q的队头元素，用e返回其值
QueuePtr p;
if(Q.front==Q.rear)//队列为空
return ERROR;
p=Q.front-next;//p指向队头结点
e=p-data;//队头元素赋给e
Q.front-next=p-next;//头结点指向下一个结点
if(Q.rear==p)//如果删除的队尾结点
Q.rear=Q.front;//修改队尾指针指向头结点
free(p);
return OK;
}
//主函数文件
#includestdio.h
#include"c6_2.h"main()
{ int i,j;
BiTree T,p,c;
TElemType e0,e1,e2,e3,e4;
InitBiTree(T);//初始化二叉树
printf("构造二叉树后，树空否?%d(1,是,0否).树的深度=%d.\n",BiTreeEmpty(T),BiTreeDepth(T));CreateBiTree(T);//建立二叉树T
printf("构造二叉树后，树空否?%d(1,是,0否).树的深度=%d.\n",BiTreeEmpty(T),BiTreeDepth(T));
e1=Root(T);//e1为二叉树T的根结点的值
if(e1!=NULL)
printf("二叉树的根为%d",e1);
else
printf("树空，无根");e2=LeftChild(T,e1);
printf("左孩子:%d",e2);
e3=RightChild(T,e1);
printf("右孩子:%d",e3);
printf("\n");printf("先序递归遍历:\n");
PreOrderTraverse(T,visit);
printf("\n");printf("后序递归遍历:\n");
PostOrderTraverse(T,visit);
printf("\n");printf("中序递归遍历:\n");
InOrderTraverse(T,visit);
printf("\n");printf("输入一个结点的值:");
scanf("%d",e1);
p=Point(T,e1);//p指向为e的指针
printf("结点的值为%d\n",Value(p));
e0=Parent(T,e1);//返回e1的双亲
printf("结点%d的双亲为%d",e1,e0);
printf("\n");e0=LeftChild(T,e1);//返回e1的左孩子
if(e0==NULL)
printf("没有孩子");
else
printf("左孩子为%d",e0);
printf("\n");e0=RightChild(T,e1);//返回e1的右孩子
if(e0==NULL)
printf("没有右孩子");
else
printf("右孩子为%d",e0);
printf("\n");
e0=RightSibling(T,e1);//返回e1的右兄弟
if(e0!=NULL)
printf("右兄弟为%d",e0);
else
printf("没有右兄弟");
printf("\n");e0=LeftSibling(T,e1);//返回e1的左兄弟
if(e0!=NULL)
printf("左兄弟为%d",e0);
else
printf("没有左兄弟");
printf("\n");
printf("要改变结点%d的值，请输入新值:",e1);
scanf("%d",e2);
Assign(p,e2);//将e2的值赋给p所指结点，代替e1
printf("层序遍历二叉树:\n");
LevelOrderTraverse(T,visit);
printf("\n");
printf("创建一棵根结点右子树为空的新树:");
CreateBiTree(c);//创建二叉树
printf("先序递归遍历二叉树c:\n");
PreOrderTraverse(c,visit);
printf("将树C插入树T中，请输入树T中树C的双亲结点C为左（0）或右（1）子树:");
scanf("%d,%d",e1,i);
p=Point(T,e1);//p指向二叉树T中将T中作为二叉树C的双亲结点的e1
InsertChild(p,i,c);//将树C插入到二叉树T中作为结点的左或右子树
printf("构造二叉树后，树空否?%d(1,是,0否).树的深度=%d.\n",BiTreeEmpty(T),BiTreeDepth(T));
printf("先序递归遍历二叉树:\n");
PreOrderTraverse(T,visit);
}
