链式二叉树遍历

前序遍历： 先根，然后左子树，最后右子树；

中序遍历： 先左子树，然后根，最后右子树；

后序遍历： 先左子树，然后右子树，最后根；

/*
     　　  A
      　　/  \
   　　 B    C
   　　/     / \
 　　D    E    F
　　/

　G

*/

#include<iostream>
#include<malloc.h>

using namespace std;

typedef struct BTNode
{
char data;
struct BTNode * pLchild;
struct BTNode * pRchild;
}BTREE;

//创建二叉树
BTREE * create_BT(void)
{
char A='A';
char B='B';
char C='C';
char D='D';
char E='E';
char F='F';
char G='G';

BTREE * pA=(BTREE *)malloc(sizeof(BTREE));
BTREE * pB=(BTREE *)malloc(sizeof(BTREE));
BTREE * pC=(BTREE *)malloc(sizeof(BTREE));
BTREE * pD=(BTREE *)malloc(sizeof(BTREE));
BTREE * pE=(BTREE *)malloc(sizeof(BTREE));
BTREE * pF=(BTREE *)malloc(sizeof(BTREE));
BTREE * pG=(BTREE *)malloc(sizeof(BTREE));

pA->data=A;
pA->pLchild=pB;
pA->pRchild=pC;

pB->data=B;
pB->pLchild=pD;
pB->pRchild=NULL;

pD->data=D;
pD->pLchild=NULL;
pD->pRchild=NULL;

pC->data=C;
pC->pLchild=pE;
pC->pRchild=pF;

pE->data=E;
pE->pLchild=NULL;
pE->pRchild=NULL;

pF->data=F;
pF->pLchild=pG;
pF->pRchild=NULL;

pG->data=G;
pG->pLchild=NULL;
pG->pRchild=NULL;

return pA;
}

//前序遍历
void PreOrderTraverse(BTREE * BT)
{
if(BT != NULL)
{
cout<<BT->data<<" ";

if(BT->pLchild !=NULL)
{
PreOrderTraverse(BT->pLchild);
}
if(BT->pRchild !=NULL)
{
PreOrderTraverse(BT->pRchild);
}
}
}

//中序遍历
void InOrderTraverse(BTREE * BT)
{
if(BT != NULL)
{
if(BT->pLchild !=NULL)
{
InOrderTraverse(BT->pLchild);
}

cout<<BT->data<<" ";

if(BT->pRchild !=NULL)
{
InOrderTraverse(BT->pRchild);
}
}
}

//后序遍历
void PostOrderTraverse(BTREE * BT)
{
if(BT != NULL)
{
if(BT->pLchild !=NULL)
{
PostOrderTraverse(BT->pLchild);
}

if(BT->pRchild !=NULL)
{
PostOrderTraverse(BT->pRchild);
}

cout<<BT->data<<" ";
}
}

 

int main()
{
BTREE * bt;
bt=create_BT();
PreOrderTraverse(bt);
cout<<endl;
InOrderTraverse(bt);
cout<<endl;
PostOrderTraverse(bt);
cout<<endl;
}