如何构建一颗二叉树

//二叉树结点类型为字符型的情况

目前创新互联公司已为上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如何创建二叉树

在二叉树中有一种平衡二叉树，通过平衡算法可以让二叉树两边的节点平均分布，这样就能让所有的索引查找都在一个近似的时间内完成。而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);

}

网站题目：mysql二叉树怎么创建,创建二叉树怎么输入数据
分享网址：http://chengdu.cdxwcx.cn/article/dscjcpg.html