设计算法后序遍历求深度

❶ 求高手编写一用层次遍历求二叉树深度的程序,谢谢

数据结构实验------二叉树操作2008-12-04 19:07按层次输入，这样可以根据实际需要建如瞎立树毁饥型，更为实用。但我的程序仍存在一个问题，就是遍历（2）：输出为空的孩子时都会多输出两个空孩子。不知道怎么改。

//二叉树结点类型为字符型的情况
#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(s&&Q[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=(hl>hr)?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==null&&bt->right==null)
count++;
}
return count;
}

void paintleaf(b_tree bt)
{
if(bt!=null)
{
if(bt->left==null&&bt->right==null)
printf("%3c"纤橡返,bt->data);
paintleaf(bt->left);
paintleaf(bt->right);
}
}

typedef b_tree ElemType ;

/*定义队列结点类型*/
typedef struct QueueNode
{
ElemType data;
struct QueueNode *next;
} QueueNode;

/*定义队列*/
typedef struct linkQueue
{
QueueNode * front;
QueueNode * rear;
}linkQueue;

/*初始化队列*/
void initQueue(linkQueue * q)
{
q->front=q->rear =null; //----无头结点
}

/*判断队列是否为空*/
int QueueEmpty(linkQueue * Q)
{
return (Q->front==null)&&(Q->rear==null);
/*实际上只须判断队头指针是否为空即可*/
}

/*入队操作*/
void EnQueue(linkQueue *Q,ElemType x)
{ /*将元素x插入链队列尾部*/

QueueNode *p=(QueueNode *)malloc(sizeof(QueueNode)); /*申请新结点*/
p->data=x; p->next=null;
if(QueueEmpty(Q)) /*将x插入空队列*/ //----无头结点
Q->front=Q->rear=p;
else
{ /*x插入非空队列的尾*/
Q->rear->next=p; /*p链到原队尾结点后*/
Q->rear=p; /*队尾指针指向新的尾*/
}
}

/*出队操作*/
ElemType DeQueue (linkQueue *Q)
{
ElemType x;
QueueNode *p;
if(QueueEmpty(Q))
{
printf("Queue underflow");/*下溢*/
exit(1) ;
}
p=Q->front; /*指向对头结点*/
x=p->data; /*保存对头结点的数据*/
Q->front=p->next; /*将对头结点从链上摘下*/
if(Q->rear==p)/*原队中只有一个结点，删去后队列变空，此时队头指针已为空*/
Q->rear=NULL;
free(p); /*释放被删队头结点*/
return x; /*返回原队头数据*/
}

void visit(b_tree p)
{
printf("%3c",p->data);
}

void breadthFirst2(b_tree root)
{
b_tree p,tmp;
linkQueue * q;
tmp=(treenode *)malloc(sizeof(treenode));
q=(linkQueue *)malloc(sizeof(linkQueue));
tmp->data='?';
initQueue(q);
p=root;
if(p!=null)
{
EnQueue(q,p);
while(!QueueEmpty(q))
{
p=DeQueue(q);
visit(p);
if(p->data!='?')
{
if(p->left!=null)
EnQueue(q,p->left);
else
EnQueue(q,tmp);
if(p->right!=null)
EnQueue(q,p->right);
else
EnQueue(q,tmp);
}
}
}
}

void breadthFirst(b_tree root)
{
b_tree p;
linkQueue * q;
q=(linkQueue *)malloc(sizeof(linkQueue));
initQueue(q);
p=root;
if(p!=null)
{
EnQueue(q,p);
while(!QueueEmpty(q))
{
p=DeQueue(q);
visit(p);
if(p->left!=null)
EnQueue(q,p->left);
if(p->right!=null)
EnQueue(q,p->right);
}
}
}

int main()
{
char nodelist[MaxSize];
int len,flag;
char cmd;
b_tree root;
printf("\n\n----------------------------------------------------\n");
printf("\n****欢迎测试和修正本程序！本程序用以研究二叉树。****\n");
printf("\n----------------------------------------------------\n\n");
do
{
printf("\n\n 请选择你要执行的操作:\n\n");
printf(" c,C......创建一棵二叉排序树\n");
printf(" a,A......结束本程序\n\n");
flag=0;
do
{
if(flag!=0)
printf("选择操作错误！请重新选择！\n");
fflush(stdin);
scanf("%c",&cmd);
flag++;
}while(cmd!='c'&&cmd!='C'&&cmd!='a'&&cmd!='A');
if(cmd=='c'||cmd=='C')
{
printf("请输入那你所要创建的二叉树的结点的值,以‘？’结束）：\n");
getchar();
root=createbtree();
do
{
flag=0;
printf("\n\n 请选择你要对这棵二叉树所做的操作:\n\n");
printf(" x,X......先序遍历这棵二叉树\n");
printf(" z,Z......中序遍历这棵二叉树\n");
printf(" h,H......后序遍历这棵二叉树\n");
printf(" b,B......层次遍历这棵二叉树\n");
printf(" d,D......求这棵二叉树的高度\n");
printf(" y,Y......求这棵二叉树的叶子总数\n");
printf(" j,J......输出这棵二叉树的叶子结点\n");
printf(" q,Q......结束对这棵二叉树的操作\n\n");
do
{
if(flag!=0)
printf("选择操作错误！请重新选择！\n");
fflush(stdin);
scanf("%c",&cmd);
flag++;
}while(cmd!='x'&&cmd!='X'&&cmd!='z'&&cmd!='Z'&&cmd!='h'&&cmd!='H'&&cmd!='b'&&cmd!='B'&&cmd!='d'&&cmd!='D'&&cmd!='y'&&cmd!='Y'&&cmd!='j'&&cmd!='J'&&cmd!='q'&&cmd!='Q');
switch(cmd)
{
case 'x':
case 'X':
printf("\n先序遍历开始:\n");
preorder_btree(root);
printf("\n先序遍历结束\n\n");
break;
case 'z':
case 'Z':
printf("\n中序遍历开始:\n");
inorder_btree(root);
printf("\n中序遍历结束\n\n");
break;
case 'h':
case 'H':
printf("\n后序遍历开始:\n");
postorder_btree(root);
printf("\n后序遍历结束\n\n");
break;
case 'b':
case 'B':
printf("\n层次遍历开始:\n");
printf("遍历（1）：不输出为空的孩子\n");
breadthFirst(root);
printf("\n");
printf("遍历（2）：输出为空的孩子\n");
breadthFirst2(root);
printf("\n层次遍历结束\n\n");
break;
case 'd':
case 'D':
printf("\n这棵二叉树的高度：\n%d\n\n",treedepth(root));
break;
case 'y':
case 'Y':
count=0;
count=leafcount(root);
printf("\n这棵二叉树的叶子总数为:\n%d\n\n",count);
count=0;
break;
case 'j':
case 'J':
printf("\n这棵二叉树的叶子结点为：\n");
paintleaf(root);
printf("\n");
break;
}
}while(cmd!='q'&&cmd!='Q');
}
}while(cmd!='a'&&cmd!='A');
printf("\n\n----------------------------\n\n");
printf("****谢谢使用！欢迎指正！****\n\n");
printf("----------------------------\n\n");
printf("作者：Remainder 学号：07082107 时间：2008.11.23\n\n\n\n");
return 0;
}

/*（10
（8 5 3 34 23 73 15 34 56 32）。。。。。。结点数据整型时
6
1 2 3 4 5 6
4
a b c d
*/

上面是我写的程序，希望对你有用！
http://hi..com/yy_christine 我的网络空间

❷ 用递归算法先序中序后序遍历二叉树

1、先序

void PreOrderTraversal(BinTree BT)

{

if( BT )

{

printf(“%d ”, BT->Data); //对节点做些访问比如打印

PreOrderTraversal(BT->Left); //访问左儿子

PreOrderTraversal(BT->Right); //访问右儿子

}

}

2、中序

void InOrderTraversal(BinTree BT)

{

if(BT)

{

InOrderTraversal(BT->Left);

printf("%d ", BT->Data);

InOrderTraversal(BT->Right);

}

}

3、后序

void PostOrderTraversal(BinTree BT)

{

if (BT)

{

PostOrderTraversal(BT->Left);

PostOrderTraversal(BT->Right);

printf("%d ", BT->Data);

}

}

(2)设计算法后序遍历求深度扩展阅读：

注意事项

1、前序遍历

从整棵二叉树的根结点开始，对于任意结点VV，访问结点VV并将结点VV入栈，并判断结点VV的左子结点LL是否为空。若LL不为空，则将LL置为当前结点VV；若LL为空，则取出栈顶结点，并将栈顶结点的右子结点置为当前结点VV。

2、中序遍历

从整棵二叉树的根结点开始，对于任一结点VV，判断其左子结点LL是否为空。若LL不为空，则将VV入栈并将L置为当前结点VV；若LL为空，则取出栈顶结点并访问该栈顶结点，然后将其右子结点置为当前结点VV。重复上述操作，直到当前结点V为空结点且栈为空，遍历结束。

3、后序遍历

将整棵二叉树的根结点入栈，取栈顶结点VV，若VV不存在左子结点和右子结点，或VV存在左子结点或右子结点，但其左子结点和右子结点都被访问过了，则访问结点VV，并将VV从栈中弹出。若非上述两种情况，则将VV的右子结点和左子结点依次入栈。重复上述操作，直到栈为空，遍历结束。

❸ 二叉树的深度算法怎么算啊

二叉树的深度算法：
一、递归实现基本思想：
为了求得树的深度，可以先求左右子树的深度，取二者较大者加1即是树的深度，递归返回的条件是若节点为空，返回0
算法：
1
int
FindTreeDeep(BinTree
BT){
2
int
deep=0;
3
if(BT){
4
int
lchilddeep=FindTreeDeep(BT->lchild);
5
int
rchilddeep=FindTreeDeep(BT->rchild);
6
deep=lchilddeep>=rchilddeep?lchilddeep+1:rchilddeep+1;
7
}
8
return
deep;
9
}
二、非递归实现基本思想：
受后续遍历二叉树思想的启发，想到可以利用后续遍历的方法来求二叉树的深度，在每一次输出的地方替换成算栈S的大小，遍历结束后最大的栈S长度即是栈的深度。
算法的执行步骤如下：
（1）当树非空时，将指针p指向根节点，p为当前节点指针。
（2）将p压入栈S中，0压入栈tag中，并令p执行其左孩子。
（3）重复步骤（2），直到p为空。
（4）如果tag栈中的栈顶元素为1，跳至步骤（6）。从右子树返回
（5）如果tag栈中的栈顶元素为0，跳至步骤（7）。从左子树返回
（6）比较treedeep与栈的深度，取较大的赋给treedeep，对栈S和栈tag出栈操作，p指向NULL，并跳至步骤（8）。
（7）将p指向栈S栈顶元素的右孩子，弹出栈tag，并把1压入栈tag。（另外一种方法，直接修改栈tag栈顶的值为1也可以）
（8）循环（2）~（7），直到栈为空并且p为空
（9）返回treedeep，结束遍历
1
int
TreeDeep(BinTree
BT
){
2
int
treedeep=0;
3
stack
S;
4
stack
tag;
5
BinTree
p=BT;
6
while(p!=NULL||!isEmpty(S)){
7
while(p!=NULL){
8
push(S,p);
9
push(tag,0);
10
p=p->lchild;
11
}
12
if(Top(tag)==1){
13
deeptree=deeptree>S.length?deeptree:S.length;
14
pop(S);
15
pop(tag);
16
p=NULL;
17
}else{
18
p=Top(S);
19
p=p->rchild;
20
pop(tag);
21
push(tag,1);
22
}
23
}
24
return
deeptree;
25
}

❹ python算法系列—深度优先遍历算法

一、什么是深度优先遍历
深度优先遍历算法是经典的图论算法。从某个节点v出发开始进行搜索。不断搜索直到该节点所有的边都被遍历完，当节点v所有的边都被遍历完以后，深度优先遍历算法则需要回溯到v以前驱节点来继续搜索这个节点。
注意：深度优先遍历问题一定要按照规则尝试所有的可能才行。

二、二叉树

2.二叉树类型
二叉树类型：空二叉树、满二叉树、完全二叉树、完美二叉树、平衡二叉树。

空二叉树：有零个节点
完美二叉树：每一层节点都是满的二叉树（如1中举例的图）
满二叉树：每一个节点都有零个或者两个子节点
完全二叉树：出最后一层外，每一层节点都是满的，并且最后一层节点全毁行历部从左排列
平衡二叉树：每个节点的两个子树的深度相差不超过1.

注：国内对完美二叉树和满二叉树定义相同
3.二叉树相关术语
术语 解释
度 节点的度为节点的子树个数
叶子节点 度为零的节点
分支节点 度不为零的节点
孩子节点 节点下的两个子节点
双亲节点 节点上一层的源节点
兄弟节点 拥有同一双亲节点的节点
根 二叉树的源头节点
深度 二叉树中节点的层的数量

DLR（先序）：
LDR（中序）：
LRD(后序）：
注意：L代表左子树R代表右子树；D代表根

6.深度优先遍历和广度优先遍历
深度优先遍历：前序、中序和后序都是深度优先遍历
从根节点出发直奔最远节点，
广度优先遍历：首先访问举例根节点最近的节纤搜点，按层次递进，以广度优先遍历上图的顺序为：1-2-3-4-5-6-7
三、面试题+励志
企鹅运维面试题：带局
1.二叉树遍历顺序：看上文
2.用你熟悉的语言说说怎么创建二叉树？ python看上文

❺ c语言 数据结构 求1、二叉树的深度；2、求二叉子树的深度 算法！！！不胜感激~~~

//递归调用求树的深度
int shen(tree *bt){ //tree是一个结构体 有一个数据域和两个指针域（rchlib lchlib）
int h,h1,h2;
if(bt==NULL) //节点让念为空节点 这说明这个节点是子节点
h=0;
else{
h1=shen(bt->洞歼rchlib);
h2=shen(bt->坦颤困lchlib);
h=(h1>h2?h1:h2)+1;
}
return h;
}

❻ 用递归的方法设计一个建立二叉树并求其深度的算法,求完整的。

先序遍历求二叉树高度int PreTreeDepth(BiTree root)
#define null 0
typedef struct node
{
elementtype data;
struct node *RChild,*LChild;
}BitNode,*BiTree;
int PreTreeDepth(BiTree root)
{/*先序遍历求二叉树高度，root为指向二叉树根结点的指针*/
int lc,rc,max=0;
if(root==null)
return max;
lc=PreTreeDepth(root->LChild);
rc=PreTreeDepth(root->RChild);
max=lc>rc?lc:rc;
return max+1;
}
后序遍历求二叉树高度int PostTreeDepth(BiTree root)
#define null 0
typedef struct node
{
elementtype data;
struct node *RChild,*LChild;
}BitNode,*BiTree;
int PostTreeDepth(BiTree root)
{/*后序遍历二叉树，root为指向二叉树（或某一子树）根结点的指针*/
int max=0;
if(root!=null)
{
max=PostTreeDepth(root->LChild)+1;
if(max<=PostTreeDepth(root->RChild))
max=PostTreeDepth(root->RChild)+1;
}
return max;
}

❼ 先序遍历和后序遍历是什么

1、先序遍历也叫做先根遍历、前序遍历，可记做根左右（二叉树父结点向下先左后右）。

首先访问根结点然后遍历左子树，最后遍历右子树。在遍历左、右子树时，仍然先访问根结点，然后遍历左子树，最后遍历右子树，如果二叉树为空则返回。

例如，下图所示二叉树的遍历结果是：ABDECF

（1）后序遍历左子树

（2）后序遍历右子树

（3）访问根结点

如右图所示二叉树

后序遍历结果：DEBFCA

已知前序遍历和中序遍历，就能确定后序遍历。

(7)设计算法后序遍历求深度扩展阅读：

图的遍历算法主要有两种，

一种是按照深度优先的顺序展开遍历的算法，也就是深度优先遍历；

另一种是按照宽度优先的顺序展开遍历的算法，也就是宽度优先遍历。宽度优先遍历是沿着图的深度遍历图的所有节点，每次遍历都会沿着当前节点的邻接点遍历，直到所有点全部遍历完成。

如果当前节点的所有邻接点都遍历过了，则回溯到上一个节点，重复这一过程一直到已访问从源节点可达的所有节点为止。

如果还存在没有被访问的节点，则选择其中一个节点作为源节点并重复以上过程，直到所有节点都被访问为止。

利用图的深度优先搜索可以获得很多额外的信息，也可以解决很多图论的问题。宽度优先遍历又名广度优先遍历。通过沿着图的宽度遍历图的节点，如果所有节点均被访问，算法随即终止。宽度优先遍历的实现一般需要一个队列来辅助完成。

宽度优先遍历和深度优先遍历一样也是一种盲目的遍历方法。也就是说，宽度遍历算法并不使用经验法则算法， 并不考虑结果的可能地址，只是彻底地遍历整张图，直到找到结果为止。图的遍历问题分为四类：

1、遍历完所有的边而不能有重复，即所谓“欧拉路径问题”（又名一笔画问题）；

2、遍历完所有的顶点而没有重复，即所谓“哈密顿路径问题”。

3、遍历完所有的边而可以有重复，即所谓“中国邮递员问题”；

4、遍历完所有的顶点而可以重复，即所谓“旅行推销员问题”。

对于第一和第三类问题已经得到了完满的解决，而第二和第四类问题则只得到了部分解决。第一类问题就是研究所谓的欧拉图的性质，而第二类问题则是研究所谓的哈密顿图的性质。

❽ 利用层序遍历非递归地求解树的深度

  求解树的深度如果用递归的话那就很简单，思想就是树的深度等于左子树深度+1和右子树深度+1的最大值，这里不再赘述，但如果用非递归的话那就可以利用层序遍历了，这个算法是在王道的数据结构书上看到的。

接下来以这个图为例解释一宽闭氏下这个算法。

下面我们来进慎散行循环：

进入循环前:front=-1,rear=0,level=0,last=0
第一次：front+1=0,rear+2=2,last=front=0,level+1=1,last=rear=2；A出队态核，BC入队。

第二次：front+1=1,rear+2=4,last=2!=front=1 ；本次B出队，DE入队。

第三次：front+1=2,rear=4,last=front=2,level+1=2,last=rear=4；本次C出队。

第四次：front+1=3,rear+1=5,last=4!=front=3；本次D出队，F入队。

第五次：front+1=4,rear=5,last=front=4,level+1=3,last=rear=5；本次E出队。

第六次：front+1=5,rear=5,last=front=5,level+1=4,last=rear=5；本次F出队。

  循环中的关键就是这个if语句，if(front==last)其实就是问这层的所有节点有没有都出队，如果都出队了，自然level+1，此时在进行last=rear操作前，rear-last的值其实就表示下一层的总节点数，因为此时该层的最后一个节点都出队了，那说明下一层的所有节点都已经进入了队中，rear-last(上一次循环的rear)就表示新进来的节点数即下一层的总节点数，所以要进行last=rear操作，使last指向该层的最后一个节点。循环结束时，树的深度自然就求出了。

❾ 1、建立二叉树，并进行先序、中序和后序遍历。 2、求二叉树的深度及叶子结点的个数。 3、构造哈夫曼树及哈

0是初始节点数
输入时请一次性输完ABCффDEфGффFффф在按ENTER键 不要输入一个按一下

#include"stdio.h"
#include"string.h"
#include"stdlib.h"
#define Max 20 //结点的最大个数
typedef struct node{
char data;
struct node *lchild,*rchild;
}BinTNode; //自定义二叉树的结点类型
typedef BinTNode *BinTree; //定义二叉树的指针
int NodeNum,leaf; //NodeNum为结点数，leaf为叶子数
//==========基于先序遍历算法创建二叉树==============
//=====要求输入先序序列，其中加入虚结点"#"以示空指针的位置==========
BinTree CreatBinTree(void)
{
BinTree T;
char ch;
if((ch=getchar())==' ')
return(NULL); //读入#，返回空指针
else{
T=(BinTNode *)malloc(sizeof(BinTNode));//生成结点
T->data=ch;
T->lchild=CreatBinTree(); //构造左子树
T->rchild=CreatBinTree(); //构造右子树
return(T);
}
}
//========NLR 先序遍历=============
void Preorder(BinTree T)
{
if(T) {
printf("%c",T->data); //访问结点
Preorder(T->lchild); //先序遍历左子树
Preorder(T->rchild); //先序遍历右子树
}
}
//========LNR 中序遍历===============
void Inorder(BinTree T)
{
if(T) {
Inorder(T->lchild); //中序遍历左子树
printf("%c",T->data); //访问结点
Inorder(T->rchild); //中序遍历右子树
}
}
//==========LRN 后序遍历============
void Postorder(BinTree T)
{
if(T) {
Postorder(T->lchild); //后序遍历左子树
Postorder(T->rchild); //后序遍历右子树
printf("%c",T->data); //访问结点
}
}
//=====采用后序遍历求二叉树的深度、结点数及叶子数的递归算法========
int TreeDepth(BinTree T)
{
int hl,hr,max;
if(T){
hl=TreeDepth(T->lchild); //求左深度
hr=TreeDepth(T->rchild); //求右深度
max=hl>hr? hl:hr; //取左右深度的最大值
NodeNum=NodeNum+1; //求结点数
if(hl==0&&hr==0) leaf=leaf+1; //若左右深度为0，即为叶子。
return(max+1);
}
else return(0);
}
//====利用"先进先出"（FIFO）队列，按层次遍历二叉树==========
void Levelorder(BinTree T)
{
int front=0,rear=1;
BinTNode *cq[Max],*p; //定义结点的指针数组cq
cq[1]=T; //根入队
while(front!=rear)
{
front=(front+1)%NodeNum;
p=cq[front]; //出队
printf("%c",p->data); //出队，输出结点的值
if(p->lchild!=NULL){
rear=(rear+1)%NodeNum;
cq[rear]=p->lchild; //左子树入队
}
if(p->rchild!=NULL){
rear=(rear+1)%NodeNum;
cq[rear]=p->rchild; //右子树入队
}
}
}
//==========主函数=================
void main()
{
BinTree root;
int i,depth;
printf("NodeNum:%d\n",NodeNum);
printf("Creat Bin_Tree； Input preorder:"); //输入完全二叉树的先序序列，
// 用#代表虚结点，如ABD###CE##F##
root=CreatBinTree(); //创建二叉树，返回根结点
do { //从菜单中选择遍历方式，输入序号。
printf("\t********** select ************\n");
printf("\t1: Preorder Traversal\n");
printf("\t2: Iorder Traversal\n");
printf("\t3: Postorder traversal\n");
printf("\t4: PostTreeDepth,Node number,Leaf number\n");
printf("\t5: Level Depth\n"); //先判断节点数是否已有。不用再先选择4，求出该树的结点数。
printf("\t0: Exit\n");
printf("\t*******************************\n");
scanf("%d",&i); //输入菜单序号（0-5）
switch (i){
case 1: printf("Print Bin_tree Preorder: ");
Preorder(root); //先序遍历
break;
case 2: printf("Print Bin_Tree Inorder: ");
Inorder(root); //中序遍历
break;
case 3: printf("Print Bin_Tree Postorder: ");
Postorder(root); //后序遍历
break;
case 4: depth=TreeDepth(root); //求树的深度及叶子数
printf("BinTree Depth=%d BinTree Node number=%d",depth,NodeNum);
printf(" BinTree Leaf number=%d",leaf);
break;
case 5:
if(!NodeNum)
TreeDepth(root);
printf("LevePrint Bin_Tree: ");
Levelorder(root); //按层次遍历
break;
default: exit(1);
}
printf("\n");
} while(i!=0);
}

❿ 用C实现二叉树的建立，先序、中序、后序历遍，深度算法。紧急！！

#include<stdio.h>//头文件

#include<stdlib.h>

#include<malloc.h>

typedefstructBiTNode

{

chardata;

structBiTNode*lchild,*rchild;

}

BiTNode,*BiTree;//定义结点类型

BiTreeCreateBiTree()//创建树

{

charp;BiTreeT;

scanf("%c",&p);

if(p=='')

T=NULL;

else

{

T=(BiTNode*)malloc(sizeof(BiTNode));//为结点开辟空间

T->data=p;

T->lchild=CreateBiTree();

T->rchild=CreateBiTree();

}

return(T);

}

voidPreOrder(BiTreeT)//先序

{

if(T!=NULL)

{

printf("%c",T->data);

PreOrder(T->lchild);

PreOrder(T->rchild);

}

}

voidInOrder(BiTreeT)//中序

{

if(T!=NULL)

{

InOrder(T->lchild);

printf("%c",T->data);

InOrder(T->rchild);

}

}

voidPostOrder(BiTreeT)//后序

{

if(T!=NULL)

{

PostOrder(T->lchild);

PostOrder(T->rchild);

printf("%c",T->data);

}

}

intDepth(BiTree态顷T)/*深度*/

{

if(T==NULL)

return(0);

else

return1+(Depth(T->lchild)>Depth(T->rchild)?Depth(T->lchild):Depth(T->rchild));

}

voidmain()//主函数

{

BiTreeTa;

渣梁Ta=CreateBiTree();

printf("先序遍历:");

printf(" ");

PreOrder(Ta);

printf(" ");

printf("中序遍历:");

printf(" ");

InOrder(Ta);

printf(" "帆梁陆);

printf("后序遍历:");

printf(" ");

PostOrder(Ta);

printf(" ");

printf("深度为：%d",Depth(Ta));

}

根据你给的树，你输入如下：

ABD**EG*J***C*FHK**L**IM***

（其中*代表空格，输入时*代表空格）

有问题联系！