二叉树的遍历例题,数据结构关于遍历二叉树的一道题目 急 急 急 在线等啊

二叉树的遍历例题,数据结构关于遍历二叉树的一道题目 急 急 急 在线等啊详细介绍

本文目录一览： 已知某二叉树的先序遍历序列是aecdb，中序遍历序列是eadcb，该二叉树的根结点是___后序遍历序列为_____

分析过程： 以下面的例题为例进行讲解： 已知一棵二叉树的先序遍历序列和中序遍历序列分别是abdgcefh、dgbaechf，求二叉树及后序遍历序列。 分析：先序遍历序列的第一个字符为根结点。对于中序遍历，根结点在中序遍历序列的中间，左边部分是根结点的左子树的中序遍历序列，右边部分是根结点的右子树的中序遍历序列。 先序：abdgcefh --> a bdg cefh 中序：dgbaechf --> dgb a echf 得出结论：a是树根，a有左子树和右子树，左子树有bdg结点，右子树有cefh结点。 先序：bdg --> b dg 中序：dgb --> dg b 得出结论：b是左子树的根结点，b无右子树，有左子树。 先序：dg --> d g 中序：dg --> d g 得出结论：d是b的左子树的根结点，d无左子树，有右子树。 先序：cefh --> c e fh 中序：echf --> e c hf 得出结论：c是右子树的根结点，c有左子树(只有e结点)，有右子树(有fh结点)。 先序：fh --> f h 中序：hf --> h f 得出结论：f是c的左子树的根结点，f有左子树(只有h结点)，无右子树。 还原二叉树为： a b c d e f g h 后序遍历序列：gdbehfca

计算机二级二叉树前序中序后序

二叉树遍历方式是数据结构的基础知识，作为计算机专业的大学生，我的理解如下：
1、 前序遍历
它的遍历顺序是：先访问根结点，再进入这个根结点的左子树；以上述方式遍历完所有左子树后，再进入它的右子树，以同样的方式遍历右子树中的结点，即根结点→左子树→右子树。下图中1为主根结点，245为左子树，367为右子树；在左子树中，2为根结点，4为左子树，5为右子树；在右子树中，3为根结点，6为左子树，7为右子树。依次将每个树中的根结点、左子树以及右子树分清，只到子树中只剩一个元素为止。综上可知，结果为1→2→4→5→3→6→7。
例子
2、 中序遍历
它的遍历顺序是：先进入根结点的左子树，以同样方式遍历左子树结点，在访问当前的根结点，最后进入根结点的右子树，以同样方式遍历右子树结点，即左子树→根结点→右子树。由前序遍历中分析可知结果为4→2→5→1→6→3→7。
3、 后序遍历
它的遍历顺序是：先进入根结点的左子树，以同样方式遍历左子树结点，再进入根结点的右子树，以同样方式遍历右子树结点，左右子树都遍历完后，才能访问当前根结点，即左子树→右子树→根结点。由前序遍历中分析可知结果为4→5→2→6→7→3→1。
试一试，二叉树例题与解答：
例题
前序遍历：A→B→D→F→G→H→I→E→C
中序遍历：F→D→H→G→I→B→E→A→C
后序遍历：F→H→I→G→D→E→B→C→A

数据结构关于遍历二叉树的一道题目 急 急 急 在线等啊

下面是二叉树的遍历题，看得部是很不明白，求解题思路，越详细越好！！！我的分不多，拜托各位！！！
32．一棵二叉树的前序遍历序列为ABCDEFG，它的中序遍历序列可能是（
）
A．CABDEFG
B．ABCDEFG
C．DACEFBG
D．ADCFEG
33．已知一棵二叉树的前序遍历结果为ABCDEF,中序遍历结果为CBAEDF,则后序遍历的结果为（
A
）。
A．CBEFDA
B．
FEDCBA
C．
CBEDFA
D．不定
34．已知某二叉树的后序遍历序列是dabec,
中序遍历序列是debac
,
它的前序遍历是（
D
）。
A．acbed
B．decab
C．deabc
D．cedba
35.
某二叉树中序序列为A,B,C,D,E,F,G，后序序列为B,D,C,A,F,G,E
则前序序列是：B
A．E,G,F,A,C,D,B
B．E,A,C,B,D,G,F
C．E,A,G,C,F,B,D
D．上面的都不对

【【求】】二叉树的三种遍历举例!!!

前序遍历:1 2 4 8 9 10 11 5 3 6 7 (规律：根在前；子树在根后且左子树比右子树靠前)；
中序遍历:8 4 10 9 11 2 5 1 6 3 7 (规律：根在中；左子树在跟左边，右子树在根右边)；
后序遍历:8 10 11 9 4 5 2 6 7 3 1 (规律：根在后；子树在根前且左子树比右子树靠前)；
其它例子：
前序遍历:ABDECFG
中序遍历:DBEAFCG
后序遍历:DEBFGCA
前序遍历:1 2 4 3 5 7 6
中序遍历:2 4 1 5 7 3 6
后序遍历:4 2 7 5 6 3 1
做类似的题目，你可以先由两个遍历画出二叉树。通过形象的二叉树来写出另一个遍历，写的方法如上（递归）。画出二叉树的方法如下：
已知一棵二叉树的前序序列和中序序列，构造该二叉树的过程如下：
1. 根据前序序列的第一个元素建立根结点；
2. 在中序序列中找到该元素，确定根结点的左右子树的中序序列；
3. 在前序序列中确定左右子树的前序序列；
4. 由左子树的前序序列和中序序列建立左子树；
5. 由右子树的前序序列和中序序列建立右子树。
已知一棵二叉树的后序序列和中序序列，构造该二叉树的过程如下：
1. 根据后序序列的最后一个元素建立根结点；
2. 在中序序列中找到该元素，确定根结点的左右子树的中序序列；
3. 在后序序列中确定左右子树的后序序列；
4. 由左子树的后序序列和中序序列建立左子树；
5. 由右子树的后序序列和中序序列建立右子树。

二叉树遍历算法，就是给定两种遍历结果求另一种遍历顺序

假设某二叉树的先序遍历序列是abdgcefh，中序遍历序列是dgbaechf，画出二叉树，并给出其后序遍历序列。分析过程：
以下面的例题为例进行讲解：
已知一棵二叉树的先序遍历序列和中序遍历序列分别是abdgcefh、dgbaechf，求二叉树及后序遍历序列。
分析：先序遍历序列的第一个字符为根结点。对于中序遍历，根结点在中序遍历序列的中间，左边部分是根结点的左子树的中序遍历序列，右边部分是根结点的右子树的中序遍历序列。先序：abdgcefh --> a bdg cefh
中序：dgbaechf --> dgb a echf
得出结论：a是树根，a有左子树和右子树，左子树有bdg结点，右子树有cefh结点。先序：bdg --> b dg
中序：dgb --> dg b
得出结论：b是左子树的根结点，b无右子树，有左子树。先序：dg --> d g
中序：dg --> d g
得出结论：d是b的左子树的根结点，d无左子树，有右子树。先序：cefh --> c e fh
中序：echf --> e c hf
得出结论：c是右子树的根结点，c有左子树(只有e结点)，有右子树(有fh结点)。先序：fh --> f h
中序：hf --> h f
得出结论：f是c的左子树的根结点，f有左子树(只有h结点)，无右子树。还原二叉树为：
a
b c
d e f
g h后序遍历序列：gdbehfca
前序遍历是什么
这个是二叉树里面的一种遍历情况，前序遍历也叫做先根遍历，可记做根左右。
前序遍历首先访问根结点然后遍历左子树，最后遍历右子树。在遍历左、右子树时，仍然先访问根结点，然后遍历左子树，最后遍历右子树。
首先从前序的第一个确定二叉树的根A，回到中序切割，将二叉树分为三部分：
左子树的中序DBGE，根A，右子树的中序CHF
再由左子树的前序可知左子树的根为B，于是左子树的中序被再次切分为三部分：
左子树的左子树中序D，左子树的根B，左子树的右子树的中序GE
类似地，由右子树的前序可知右子树的根为C，于是右子树的中序也被切分为三部分：
右子树的左子树为空，右子树的根C，右子树的左子树的中序HF
继续切分下去：GE的根为E、HF的根为F，直到每棵子树只有一个结点为止，最终得到的完整二叉树如下：
于是后序遍历序列为：DGEBHFCA

已知二叉树后序遍历是dabec,中序遍历是debac，求该二叉树的先序遍历。（这种类型的题目又怎么

思路是：首先看后序遍历，后序遍历是先左再右最后根，所以后序遍历最后一个肯定是根结点。所以这里根结点是c,然后看一下c这个结点在中序中的问题，中序遍历是先左再最后右，所以中序序列中，c左边的为c的左子树这边，右边有右子树这边。这里中序debac，所以该树没有右子树，只有左子树。
然后针对c的左子树递归上述过程，构建完树。
下面是我的创建过程，首先确定了c
c
/ \
未知树 无
后序倒数第二个e,确定e未知树的根，然后看中序，d在e左边，ba在右边，d是左子树确定，ba还需要进一步判断
c
/
e
/ \
d 未知数
看后序倒数第三个b,所以未知树的根是b，确定b，然后看b中序中的位置，左边无，右边a，所以最终该二叉树如下
c
/
e
/ \
d b
\
a
最后根据该树核对一下后序和中序，没有问题，所以根据该树先序遍历是cedba

设一颗二叉树的中序遍历结果是DBEAFC，前序遍历结果是ABDECF，则后序便利结果是什么？

好吧，虽然没给分，我就牺牲点吧，记得采纳啊
前序遍历得知A是根节点，在中序遍历中，A讲节点非分根节点A左右子树：即
A
DBE FC
下面看DBE序列，在前序遍历中，这三个的先后顺序是BDE，所以这三个节点中B是根节点，根据中序遍历结果，该三个节点顺序是DBE，所以B讲着三个节点划分为左右节点：结果如下：
A
B FC
D E
下面再看FC两个节点，他们在前序遍历结果中的结果是CF，所以C是这两个节点中的根节点，再根据他们在中序遍历结果中的顺序FC，则F将他们本身划分为左子树（此时为空）和右子树C，则二叉树示意图如下：
A
B C
D E 空 F
后续遍历结果就不需要我写了吧，嘿嘿，望采纳
根据前序遍历ABDECF，可知二叉树的根节点是A，由此把中序遍历DBEAFC分为了两部分DBE和FC，此时可以确定DBE是A的左子树，FC是A的右子树。前序遍历的第二个节点是B，再根据中序遍历中DBE的顺序，可以确定D为B的左孩子，E为B的右孩子；同理，前序遍历为CF，中序遍历为FC，可以确定F为C的左孩子就是这样了
中序遍历结果是DBEAFC，前序遍历结果是ABDECF，则后序遍历结果是DEBFCA
（因为前序遍历结果是ABDECF，知道根结点为A，中序遍历结果是DBEAFC，知道DBE为左子树，FC为右子树，再推出DE是B的叶子结点，F是C的叶子结点。前序遍历结果是ABDECF，知道D是B的左叶子结点，E是B的右边叶子结点。这样就能画出二叉树了，后序遍历自己就能写了啊）清楚以下概念：
中序遍历：先遍历左子树，然后访问根结点，最后遍历右子树
前序遍历：先访问根结点，然后遍历左子树，最后遍历右子树
后序遍历：先遍历左子树，然后遍历右子树，最后访问根结点
例题可以参照百度文库
http://baike.baidu.com/view/549587.htm
能看明白吗？个人觉得知道概念就好解决了，画出二叉树的图
这种题就是根据这两个序列画出对应的树。
前序遍历结果是ABDECF
中序遍历结果是DBEAFC
1.先看前序，那么最先遍历的就是A,因为是前根遍历，所以A就是最根的结点，也就是所说的root结点。（这要看懂，这个不懂理解就有点恼火）
2.先在确立了一个根A.。那么现在去看中序遍历。中序是根是在遍历完左右子树再访问的根，所以DBE是A的左子树的结点。FC是A的右子树。
3.对于左子树的DBE结点。那么哪一个是根结点呢，现在就和步骤1一样。看前根中DBE中的哪个是最先出现的，那么它就是这三个结点的根。那么得出是B.然后找出B的左右子树分别是D和E。如此循环。就可以得出结果了。不明白再问。
后序遍历结果是DEBFCA。
前序遍历得知A是根节点，在中序遍历中，A讲节点非分根节点A左右子树：即
A
DBE FC
下面看DBE序列，在前序遍历中，这三个的先后顺序是BDE，所以这三个节点中B是根节点，根据中序遍历结果，该三个节点顺序是DBE，所以B讲着三个节点划分为左右节点：结果如下：
A
B FC
D E
下面再看FC两个节点，他们在前序遍历结果中的结果是CF，所以C是这两个节点中的根节点，再根据他们在中序遍历结果中的顺序FC，则F将他们本身划分为左子树（此时为空）和右子树C，则二叉树示意图如下：
A
B C
D E 空 F
扩展资料：树的3种最重要的遍历方式分别称为前序遍历、中序遍历和后序遍历。以这3种方式遍历一棵树时，若按访问结点的先后次序将结点排列起来，就可分别得到树中所有结点的前序列表、中序列表和后序列表。相应的结点次序分别称为结点的前序、中序和后序。
如果T是一棵空树，那么对T进行前序遍历、中序遍历和后序遍历都是空操作，得到的列表为空表。
如果T是一棵单结点树，那么对T进行前序遍历、中序遍历和后序遍历根，树根的子树从左到右依次为T1,T2,..,Tk，那么有：
对T进行前序遍历是先访问树根n，然后依次前序遍历T1,T2,..,Tk。
对T进行中序遍历是先中序遍历T1，然后访问树根n，接着依次对T2,T2,..,Tk进行中序遍历。
对T进行后序遍历是先依次对T1,T2,..,Tk进行后序遍历，最后访问树根n。
参考资料来源：百度百科-遍历

高分求二叉树的建立例题，以及三种遍历

/* bu用递归法输出中序和后续*/
#include "stdio.h"
#include "stdlib.h"
#define A 25
typedef struct Btree
{ char data;
struct Btree *lchild,*rchild;
}*tree,t2ree;
t2ree *creat()
{ tree t;
char ch;
scanf("%c",&ch);
if(ch=='#')
t=NULL;
else
{ t=(t2ree *)malloc(sizeof(t2ree));
t->data=ch;
t->lchild=creat();/* 开始格式不正确啊 ，就是我用了这个creat(r->rchild),所以对导致
指针乱算*/
t->rchild=creat();
}
return t;
}
/*显示用先序遍历*/
void preorder(tree t)
{ t2ree *s[A] ;
int top=0;
do
{ while(t!=NULL)
{ printf("%c",t->data);
if(t->rchild!=NULL)
s[top++]=t->rchild ; /*是右子树的地址*/
t=t->lchild; /* 再就是这个地方我加了一个{}结果导致了错误*/
}
if(top>=0)
t=s[--top];
}while(top>=0);
}
/* 中序遍历*/
void inorder(tree t)
{
tree s[A],p;
int top=0;
p=t;
do
{ while(p!=NULL)
{ s[top++]=p;
p=p->lchild;
}
if(top>=0)
{ p=s[--top];
printf("%c",p->data);
p=p->rchild;
}
}while(top>=0);
}
/* 后续遍历*/
void postorder(tree t)
{ int top=0,s2[A],b;
tree s1[A],p;
p=t;
do
{
while(p!=NULL)
{s1[top]=p;
s2[top++]=0;
p=p->lchild;
}
if(top>=0)
{ b=s2[--top];
p=s1[top];
if(b==0)
{ s1[top]=p;
s2[top++]=1;
p=p->rchild;
}
else
{ printf("%c",p->data);
p=NULL;
}
}
}while(top>0);
}
/* 求深度*/
int deep(tree t)
{ int i=0,j=0;
if(!t)
return 0;
else
{ i=deep(t->lchild);
j=deep(t->rchild);
}
return((i>j?i:j)+1);
}
/*求叶子的个数*/
int thief(tree t)
{ int i=0,j=0;
if(!t)
return 0;
else
{i=thief(t->lchild);
j=thief(t->rchild);
}
if(i==0&j==0)
return(1);
else
return(i+j);
}
main()
{ tree s;
s=creat();
printf("\XIAN xu shu chu \n");
preorder(s);
printf("\n kai shi zhong xu :\n");
inorder(s);
printf("\n hou xu :\n");
postorder(s);
printf("\n the shen du is %d\n",deep(s));
printf("\n the ye zi is %d\n",thief(s));
getch();
}
#include

#include

#define ELEMTP int

struct node

{

ELEMTP data;

struct node *lc,*rc;

};

struct node *root;

int m=0;

main()

{

int cord;

struct node* creat();

void preorderz(struct node *t);

void inorder(struct node *t);

void postorder(struct node *t);

void deletes(struct node *t,struct node *p,struct node *f);

do

{

printf("\n 主菜单 \n");

printf(" 1 建立二叉树 \n");

printf(" 2 先序非递归遍历 \n");

printf(" 3 中序递归遍历 \n");

printf(" 4 后序递归遍历，求叶节点数 \n");

printf(" 5 删除节点 \n");

printf(" 6 结束程序运行 \n");

printf("---------------------------------------\n");

printf("请输入您的选择(1, 2, 3, 4, 5, 6)");

scanf("%d",&cord);

switch(cord)

{

case 1:

{

root=creat(); // 建立二叉树

printf("建立二叉树程序以执行完，\n");

printf("请返回主菜单，用遍历算法验证程序的正确性 \n");

}break;

case 2:

{

preorderz(root);

}break;

case 3:

{

inorder(root);

}break;

case 4:

{

postorder(root);

}break;

case 5:

{

//deletes(root)

}

case 6:

{

printf("二叉树程序执行完，再见！\n");

exit(0);

}

}

}while(cord<=6);

}

struct node* creat()

{

struct node *t,*q,*s[30];

int i,j,x;

printf("i,x=");

scanf("%d%d",&i,&x);//i是按满二叉树编号，x节点应有的序号，x是节点的数据

while((i!=0)&&(x!=0))

{

q=(struct node*)malloc(sizeof(struct node));

q->data=x;

q->lc=NULL; q->rc=NULL;

s[i]=q;

if(i==1)

t=q; //t代表树根节点

else

{

j=i/2; //双亲节点的编号

if((i%2)==0)

s[j]->lc=q;

else

s[j]->rc=q;

}

printf("i,x=");

scanf("%d%d",&i,&x);

}

return(t);

}

/*void preorderz(struct node* p)//前序非递归算法

{

struct node *q,*s[30]; //s辅助栈

int top,bools;

q=p;top=0; //栈顶指针

bools=1; //bools=1为真值继续循环；bools=0为假时栈空，结束循环

do

{

while(q!=NULL)

{

printf("%6d",q->data); //访问节点

top++;

s[top]=q;

q=q->lc;

}

if(top==0)

bools=0;

else

{

q=s[top];

top--;

q=q->rc;

}

}while(bools);

printf("\n");

}//////////////////////////结束preorderz*/

void preorderz(struct node* p)//前序递归遍历

{

if(p!=NULL)

{

printf("%6d",p->data);

inorder(p->lc);

inorder(p->rc);

}

}

void inorder(struct node* p)//中序非递归遍历

{

struct node *s[30],*q;

int top,bools;

q=p;top=0;

bools=1;

do

{

while(q!=NULL)

{

top++;

s[top]=q;

q=q->lc;

}

if(top==0)

bools=0;

else

{

q=s[top];

top--;

printf("%6d",q->data);

q=q->rc;

}

}while(bools);

}

/*void inorder(struct node* p)

{

if(p!=NULL)

{

inorder(p->lc);

printf("%6d",p->data);

inorder(p->rc);

}

}//////////////////////////结束inorder*/

void postorder(struct node* p)

{

struct node *s[30],*s2[30],*q;

int top,bools;

q=p;top=0;

bools=1;

do

{

while(q!=NULL)

{

top++;

s[top]=q;

s2[top]=1;

q=q->lc;

}

if(top==0)

bools=0;

else

{

if(s2[top]==1)

{

s2[top]=2;

q=s[top];

q=q->rc;

}

else

{

q=s[top];

s2[top]=0;

top--;

printf("%6d",q->data);

q=NULL;

}

}

}while(bools);

}

void deletes(struct node *t,struct node *p,struct node *f)

{

struct node *s,*q;

int bools=1;

if(p->lc==NULL)

s=p->rc;

else if(p->rc==NULL)

{

s=p->rc;

while(s->lc!=NULL)

{

q=s;

s=s->rc;

}

if(q==p)

q->rc=s->rc;

else

q->lc=s->rc;

p->data=s->data;

free(s);

bools=0;

}

if(bools==1)

{

if(f==NULL)

t=s;

else if(f->lc==p)

f->lc=s;

else

f->rc=s;

free(p);

}

}

/*void postorder(struct node* p)

{

if(p!=NULL)

{

postorder(p->lc);

postorder(p->rc);

printf("%6d",p->data);

if(p->lc==NULL&&p->rc==NULL)

m++; //统计叶子节点

}

}//////////////////////////结束postorder*/

#include

#include

typedef char datatype;

typedef struct node /*二叉树结点定义*/

{

datatype data;

struct node *lchild,*rchild;

}bintnode;

typedef bintnode *bintree;

void createbintree(bintree *t)

{/*按照前序遍历的顺序建立一棵给定的二叉树*/

char ch;

if ((ch=getchar())==' ')

*t=NULL;

else {

*t=(bintnode *)malloc(sizeof(bintnode));

(*t)->data=ch;

createbintree(&(*t)->lchild);

createbintree(&(*t)->rchild);

}

}

void preorder(bintree t)

{/*前序遍历二叉树的递归算法*/

if (t) { printf("%c",t->data);

preorder(t->lchild);

preorder(t->rchild);

}

}

main() /*主程序*/

{ bintree root;

printf("\n");

createbintree(&root);

printf("\n");

printf("\n前序遍历结果是: ");

preorder(root);

}

我们学校的， 你参考下，或许对你有用

这是前序的，

#include

#include

typedef struct node{

char data;

struct node *lchild;

struct node *rchild;

}node,*BinTree;

void inorder(node *p,int n)

{

if(p!=NULL)

{

int i;

inorder(p->lchild,n+1);

for(i=0;i
<n;i++)
printf("----------");

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

printf("\n");

inorder(p->rchild,n+1);

}

}

void create(BinTree *p)

{

char data;

printf("Please input a word:");

scanf("%s",&data);

if(data=='#')

p=NULL;

else

{

*p=(node *)malloc(sizeof(node));

if(*p==NULL)

{

printf("Ask for free faid!\n");

exit(1);

}

(*p)->data=data;

create(&(*p)->lchild);

create(&(*p)->rchild);

}

}

void main()

{

BinTree root;

create(&root);

inorder(root,0);

}

我上机报告的代码和截图

#include

using namespace std;

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

#define OVERFLOW -2

typedef int Status;

typedef char BiElemType;

// 二叉树的数据结构定义

typedef struct BiNode

{

BiElemType data;

BiNode *lchild,*rchild;

}BiNode,*BiTree;

//构造一棵二叉树，并且按照前序遍历的方式赋值

Status CreateBiTree(BiTree &T)

{

BiElemType ch;

cin>>ch;

if(ch=='#')T=NULL;

else

{

if(!(T=(BiNode *)malloc(sizeof(BiNode))))exit(OVERFLOW);

T->data=ch;

CreateBiTree(T->lchild);

CreateBiTree(T->rchild);

}

return OK;

}

//先序遍历

Status preorder(BiTree T)

{

if(T)

{

if(cout<

data<<' ')

if(preorder(T->lchild))

if(preorder(T->rchild))return OK;

return ERROR;

}

else return OK;

}

//中序遍历

Status inorder(BiTree T)

{

if(T)

{

if(inorder(T->lchild))

if(cout<

data<<' ')

if(inorder(T->rchild))return OK;

return ERROR;

}

else return OK;

}

//后序遍历

Status postorder(BiTree T)

{

if(T)

{

if(postorder(T->lchild))

if(postorder(T->rchild))

if(cout<

data<<' ')return OK;

return ERROR;

}

else return OK;

}

int main()

{

BiTree BiT;

cout<<"以先序顺序输入二叉树的数据，以#表示空节点："<
<endl;
CreateBiTree(BiT);

cout<<"以中序遍历输出：";

inorder(BiT);

cout<
<endl;
cout<<"以先序遍历输出：";

preorder(BiT);

cout<
<endl;
cout<<"以后序遍历输出：";

postorder(BiT);

cout<
<endl;
return 0;

}
</endl;
</endl;
</endl;
</endl;

</n;i++)

请根据这图这棵二叉树完成如下题目：

先序遍历序列: A B D E C F中序遍历序列: D B E A C F后序遍历序列: D E B F C A二叉树示意图: A / \ B C / \ \ D E F//C语言测试程序#include "stdio.h"#include "stdlib.h"struct tree{ char data; struct tree *left; struct tree *right;};typedef struct tree treenode;typedef treenode *btree;btree createbtree(char *data,int pos,int maxPos) //递归创建法{ btree newnode; if(data[pos]==0 || pos>maxPos) { return NULL; } else { newnode=(btree)malloc(sizeof(treenode)); newnode->data=data[pos]; newnode->left=createbtree(data,2*pos,maxPos); newnode->right=createbtree(data,2*pos+1,maxPos); return newnode; }}void inorder(btree ptr){ if(ptr!=NULL) { inorder(ptr->left); printf("%C ",ptr->data); inorder(ptr->right); }}void preorder(btree ptr){ if(ptr!=NULL) { printf("%C ",ptr->data); preorder(ptr->left); preorder(ptr->right); }}void postorder(btree ptr){ if(ptr!=NULL) { postorder(ptr->left); postorder(ptr->right); printf("%C ",ptr->data); }}int main(){ btree root=NULL; int i; char data[16]={0,'A','B','C','D','E',0,'F',0,0,0,0,0,0,0,0}; root=createbtree(data,1,15); printf("二叉树的顺序存储内容: "); for(i=1;i<16;i++) { if(data[i]==0) { printf("^ "); } else { printf("%c ",data[i]); } } printf("\n先序遍历序列: "); preorder(root); printf("\n中序遍历序列: "); inorder(root); printf("\n后序遍历序列: "); postorder(root); printf("\n"); return 0;}