二叉树遍历 实现

// BiTree.cpp : Defines the entry point for the console application.
//
#include <afx.h>

#include "stdafx.h"

//CDumpContext dc;

//树的数据结构定义

typedef struct BTNode
{ 
 char  data ;
 struct BTNode  *Lchild , *Rchild,*Parent;
}BTNode ;

BTNode * g_biTree = NULL;

//新建一个树节点

void CreateNewNode( BTNode **newNode, char data )
{
 *newNode = new BTNode();
 (*newNode)->data = data;
 (*newNode)->Lchild = NULL;
 (*newNode)->Rchild = NULL;
 (*newNode)->Parent = NULL;
}

 

//初始化树节点

void IniteBiTree()
{
 BTNode *newNode = NULL;
 CreateNewNode(&newNode,'a');
 g_biTree = newNode;

 CreateNewNode(&newNode,'b');
 g_biTree->Lchild = newNode;
 g_biTree->Lchild->Parent = g_biTree;

 CreateNewNode(&newNode,'c');
 g_biTree->Lchild->Lchild = newNode;
 g_biTree->Lchild->Lchild->Parent = g_biTree->Lchild;

 CreateNewNode(&newNode,'d');
 g_biTree->Lchild->Rchild = newNode;
 g_biTree->Lchild->Rchild->Parent = g_biTree->Lchild;

 CreateNewNode(&newNode,'e');
 g_biTree->Lchild->Rchild->Lchild = newNode;
 g_biTree->Lchild->Rchild->Lchild->Parent = g_biTree->Lchild->Rchild;

 CreateNewNode(&newNode,'f');
 g_biTree->Lchild->Rchild->Rchild = newNode;
 g_biTree->Lchild->Rchild->Rchild->Parent = g_biTree->Lchild->Rchild;

 CreateNewNode(&newNode,'g');
 g_biTree->Lchild->Rchild->Lchild->Lchild = newNode;
 g_biTree->Lchild->Rchild->Lchild->Lchild->Parent = g_biTree->Lchild->Rchild->Lchild;
}

//显示树节点数据
void showData(char data)
{
 printf("%c",data);
}

//回归算法前序遍历树

void preorderTravers_recursive(BTNode *T)
{
 if ( NULL != T )
 {
  showData(T->data);
  preorderTravers_recursive(T->Lchild);
  preorderTravers_recursive(T->Rchild);
 }
}

//非回归算法前序遍历树

void preorderTravers_private(BTNode *T)
{
 BTNode *p = T;
 BTNode *q = NULL;
 BTNode * stack[512] = {0};
 int top = 0;
 do
 {
  showData(p->data);
  q = p->Rchild;
  if ( NULL != q )
  {
   stack[++top] = q;
  }

  p = p->Lchild;
  if ( NULL == p )
  {
   p = stack[top];
   top--;
  }
 } while ( NULL != p  );
}

 

//回归算法中序遍历树

void InorderTravers_recursive(BTNode *T)
{
 if ( NULL != T )
 {
  InorderTravers_recursive(T->Lchild);
  showData(T->data);
  InorderTravers_recursive(T->Rchild);
 }
}

 

//非回归算法中序遍历树

void InorderTravers_private(BTNode *T)
{
 BTNode *p = T;
 BTNode *q = NULL;
 BTNode * stack[512] = {0};
 int top = 0;

 do
 {
  if ( NULL != p )
  {
   stack[++top] = p;
   p = p->Lchild;
  }
  else
  {
   p = stack[top];
   top--;
   showData(p->data);
   
   p = p->Rchild;
  }
 } while ( 0 != top );
 
}

 

//回归算法后序遍历树

void postorderTravers_recursive(BTNode *T)
{
 if ( NULL != T )
 {
  postorderTravers_recursive(T->Lchild);
  postorderTravers_recursive(T->Rchild);
  showData(T->data);
 }
}

 

//非回归算法后序遍历树

void postorderTravers_private(BTNode *T)
{
 BTNode *p = T;
 BTNode *q = NULL;
 BTNode * stack[512] = {0};
 int top = 0;

 do
 {
  if ( NULL != p )
  {
   stack[++top] = p;
   p = p->Lchild;
  }
  else
  {
   p = stack[top];
   top--;
   if ( NULL != p->Rchild )
   {
    stack[++top] = p;
    p = p->Rchild;
    p->Parent->Rchild = NULL;
   }
   else
   {
    showData(p->data);
    p = NULL;
   }
  }
 } while ( 0 != top );
}

 

//层次遍历

#define MAX_NODE  50
void  LevelorderTraverse( BTNode  *T)
{ 
 BTNode  *Queue[MAX_NODE] = {0} ;
 BTNode  *p = T;
 int  front=0 , rear=0 ;
 if (p!=NULL)
 { 
  Queue[++rear]=p;    /*   根结点入队  */
  while(front < rear)
  { 
   p=Queue[++front]; 
   showData( p->data );
   if (p->Lchild!=NULL)
   {
    Queue[++rear]=p->Lchild;    /*   左结点入队  */
   }
   if (p->Rchild!=NULL)
   {
    Queue[++rear]=p->Rchild;    /*   右结点入队  */
   }
  }
 }
}

int main(int argc, char* argv[])
{
 IniteBiTree();
 //clear();
 preorderTravers_private(g_biTree);
 showData('\n');
 InorderTravers_private(g_biTree);
 showData('\n');
 postorderTravers_private(g_biTree);

 return 0;
}

结果显示：

abcdgf

cbgedfa

cgefdba