用c或c++实现遍历二叉树的中序算法,急求

如题所述

#include<stdio.h>
#include<malloc.h>
#define MaxSize 100
typedef char ElemType;
typedef struct node
{
ElemType data;
struct node *lchild;
struct node *rchild;
}BTNode;
void CreateBTNode(BTNode *&b,char *str)
{
BTNode *St[MaxSize],*p=NULL;
int top=-1,k,j=0;
char ch;
b=NULL;
ch=str[j];
while(ch!='\0')
{
switch(ch)
{
case'(':top++;St[top]=p;k=1;break;
case')':top--;break;
case',':k=2;break;
default:p=p=(BTNode * )malloc(sizeof(BTNode));
p->data=ch;p->lchild=p->rchild=NULL;
if(b==NULL)
b=p;
else
{
switch(k)
{
case 1:St[top]->lchild=p;break;
case 2:St[top]->rchild=p;break;
}
}
}
j++;
ch=str[j];
}
}
void DispBTNode(BTNode *b)
{
if(b!=NULL)
{
printf("%c",b->data);
if(b->lchild!=NULL||b->rchild!=NULL)
{
printf("(");
DispBTNode(b->lchild);
if(b->rchild!=NULL)
printf(",");
DispBTNode(b->rchild);
printf(")");
}
}
}
extern void CreateBTNode(BTNode *&b,char *str);
extern void DispBTNode(BTNode *b);
void PreOrder(BTNode *b)
{
if(b!=NULL)
{
printf("%c",b->data);
PreOrder(b->lchild);
PreOrder(b->rchild);
}
}
void PreOrder1(BTNode *b)
{
BTNode *St[MaxSize],*p;
int top=-1;
if(b!=NULL)
{
top++;
St[top]=b;
while(top>-1)
{
p=St[top];
top--;
printf("%c",p->data);
if(p->rchild!=NULL)
{
top++;
St[top]=p->rchild;
}
if(p->lchild!=NULL)
{
top++;
St[top]=p->lchild;
}
}
printf("\n");
}
}
void InOrder(BTNode *b)
{
if(b!=NULL)
{
InOrder(b->lchild);
printf("%c",b->data);
InOrder(b->rchild);
}
}
void InOrder1(BTNode *b)
{
BTNode *St[MaxSize],*p;
int top=-1;
if(b!=NULL)
{
p=b;
while(top>-1||p!=NULL)
{
while(p!=NULL)
{
top++;
St[top]=p;
p=p->lchild;
}
if(top>-1)
{
p=St[top];
top--;
printf("%c",p->data);
p=p->rchild;
}
}
printf("\n");
}
}
void PostOrder(BTNode *b)
{
if(b!=NULL)
{
PostOrder(b->lchild);
PostOrder(b->rchild);
printf("%c",b->data);
}
}
void PostOrder1(BTNode *b)
{
BTNode *St[MaxSize];
BTNode *p;
int flag,top=-1;
if(b!=NULL)
{
do
{
while(b!=NULL)
{
top++;
St[top]=b;
b=b->lchild;
}
p=NULL;
flag=1;
while(top!=-1&&flag)
{
b=St[top];
if(b->rchild==p)
{
printf("%c",b->data);
top--;
p=b;
}
else
{
b=b->rchild;
flag=0;
}
}
}
while(top!=-1);
printf("\n");
}
}
void TravLevel(BTNode *b)
{
BTNode *Qu[MaxSize];
int front,rear;
front=rear=0;
if(b!=NULL)
printf("%c",b->data);
rear++;
Qu[rear]=b;
while(rear!=front)
{
front=(front+1)%MaxSize;
b=Qu[front];
if(b->lchild!=NULL)
{
printf("%c",b->lchild->data);
rear=(rear+1)%MaxSize;
Qu[rear]=b->lchild;
}
if(b->rchild!=NULL)
{
printf("%c",b->rchild->data);
rear=(rear+1)%MaxSize;
Qu[rear]=b->rchild;
}
}
printf("\n");
}
void main()
{
BTNode *b;
CreateBTNode(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
printf("二叉树b:");DispBTNode(b);printf("\n\n");
printf("层次遍历序列:");
TravLevel(b);
printf("\n");
printf("先序遍历序列:\n");
printf("递归算法:");PreOrder(b);printf("\n");
printf("非递归算法:");PreOrder1(b);printf("\n");
printf("先序遍历序列:\n");
printf("递归算法:");InOrder(b);printf("\n");
printf("非递归算法:");InOrder1(b);printf("\n");
printf("后续遍历算法:\n");
printf("递归算法:");PostOrder(b);printf("\n");
printf("非递归算法:");PostOrder1(b);printf("\n");
}
温馨提示:答案为网友推荐,仅供参考
第1个回答  2012-12-14
,诠释计数)
{/ /递归方法,
(T)
{
((T-> lchild)&&(T-> rchild)) BR />数+ +;
CountLeaf(T-> lchild,计数); / /统计的左子树的叶结点
CountLeaf(T-> rchild数)/ /统计数量的右子树叶节点
}
}
----------
非递归,也就是序/序/后序遍历所有节点,并统计。在这里,我们给你的统计方法有三个功能(PS:因为计数器被定义为全球性的,所以三个功能不能同时使用,使用一个节点的统计数据,你希望能够)。
包括“stdlib.h中”
定义MAXNODE 20
定义ISIZE 8
定义NSIZE0 7
定义NSIZE1 8
定义NSIZE2 15
/ / SHOWCHAR = 1(显示的字符)SHOWCHAR = 0(数字显示)
定义SHOWCHAR 1

/ /二进制树结构
结构BTNode BR /> {
int数据;
BTNode * rchild;
BTNode * lchild;

/ /非递归的结构ABTStack倍堆栈

{
BTNode * ptree
ABTStack *链接;

静态的Pcounter = 0; / /计数器,记录节点的数量
/ *
遍历函数pre_Order_Access()“非递归算法的
参数描述:
BTNode *头:根节点的指针
* /
无效pre_Order_Access( BTNode *头)
{
BTNode * PT
ABTStack * PS *最高;
PT =头;
顶部= NULL;
输出( “\ n二叉树的前序遍历结果:\ t”);
(pt! = NULL | |顶= NULL)/ *不移动完成后,或堆栈非空* / /> {
(pt! = NULL)
{
如果(SHOWCHAR)
printf的(“%c”的,PT->数据); / *访问根节点* /
其他
printf的(“%d”的,PT->数据); / *访问根结点* /
PS =(ABTStack *)的malloc(sizeof(ABTStack)的) / *根节点入堆栈* /
PS-ptree = PT
PS - > =畅销;
= PS;
PT = PT-> lchild / *通过节点的节点遍历右子树变成的堆栈* /
的Pcounter + +;
}
(top! = NULL)
{
> PT =畅销 - > ptree; / *从堆栈顶部的协议栈节点* /
PS =顶部;
顶部顶部 - >链接;
免费(PS); / *松开顶部的协议栈节点空间* /
PT = PT-> rchild; / *遍历节点的右子树* /
}
}
}
BR /> / *
序遍历的功能mid_Order_Access()
参数说明:
BTNode *头:根节点指针
* / :无效mid_Order_Access(BTNode *头)
{
BTNode * PT
ABTStack * PS *最高;
int计数器= 1;
PT =头; BR />顶= NULL;
printf的(“\ n二叉树中序遍历的结果:\ t”);
而(pt! = NULL | |顶! NULL)/ *没有遍历完,或堆栈非空* /
{
而(pt! = NULL)
{
PS =(ABTStack *)malloc的(大小(ABTStack)); / *根节点入堆栈* /
PS-ptree = PT
PS - > =畅销
顶部= PS;
角= PT - > lchild; / *右子树的遍历节点,通过节点变成堆栈* /
的Pcounter + +;
}
(top! = NULL) {
PT =顶级ptree / *顶部的协议栈节点从堆栈* /
PS =顶部;
顶部=畅销 - >链接;
免费( PS); / *释放顶部的协议栈节点空间* /
(SHOWCHAR)
printf的(“%c”的,PT->数据); / *访问的根节点* / BR />其他
的printf的("% d", pt->数据); / *访问根结点* /
PT = PT-> rchild; / *遍历节点的右子树* /
}
}

}

/ *
序遍历功能last_Order_Access()
参数说明:
BTNode *头:根节点的指针
* /
:无效last_Order_Access(BTNode *头)
{
BTNode * PT
ABTStack * PS *最高;
int计数器= 1;
PT =头;
= NULL;
printf(“请\ n位二进制树后序遍历的结果:\ t“);
(pt! = NULL | |顶!= NULL)/ *遍历结束后,或堆栈非空* /
{
在while(pt! = NULL)
{
PS =(ABTStack *)的malloc(sizeof(ABTStack)的); / *根节点入堆栈* /
PS- ptree = PT
PS - > =畅销;
= PS,
PT = PT-> lchild; / *右子树的遍历节点的节点通过转压入堆栈* /
的Pcounter + +;
}
(top! = NULL)
{
PT =顶部 - > ptree; / *顶部的协议栈节点栈* /
PS =顶部;
顶部顶部 - >链接;
免费(PS)/ *释放的堆栈顶部的节点空间* /
输出( “%C”,PT->数据); / *访问根结点* /
磅= PT-> rchild; / *遍历节点的右子树* /
} }}
第2个回答  2012-12-03
void InOrder(BiTree root)
{
if(root!=NULL)
{
InOrder(root->LChild);
cout<<root->data<<endl;
InOrder(root->RChild);
}
}
这是递归算法,非递归用栈存储结点,每次循环右孩子先入栈,然后左孩子入栈本回答被提问者和网友采纳
第3个回答  2012-12-06
///利用循环队列按照层次遍历二叉树
//定义队列
typedef structqueue
{
BT *base;
int front;
int rear;
}queue;
//队列实现
voidQueueStart(queue &Q) //队列的初始化
{
Q.base=(BT *)malloc(size*sizeof(BT));
if(!Q.base)
exit(0);
Q.front=0;
Q.rear=0;
}
voidQueueInt(queue &Q,BT &p) //入队
{
if((Q.rear+1)%size==Q.front)
return ;
Q.base[Q.rear]=p;
Q.rear=(Q.rear+1)%size;
}
voidQueueOut(queue &Q,BT &p) //出队
{
printf("%c ",p->data);
if(Q.rear==Q.front)
return ;
p=Q.base[Q.front];
Q.front=(Q.front+1)%size;
}
//实现用循环队列遍历二叉树
void leveltree(BT&B)
{
queue S;
BT p;
p=B;
QueueStart(S);
if(p)
{
QueueInt(S,p);
while(S.rear!=S.front)
{
QueueOut(S,p);
if(p->lchild)
QueueInt(S,p->lchild);
if(p->rchild)
QueueInt(S,p->rchild);
}
}

}
遍历的二叉树还有的就是递归,自己去看
相似回答