二叉树的非递归访问

 #include <iostream>
#include <stack>
using namespace std;

struct Infor
{
 char  word;
 int  nFlags;
 struct Infor *lchild, *rchild, *next;
};

class Test
{
public:
 Test();

 void CreatTree();

 void PreOrder();
 void PrePassToReturn();

 void MidOrder();
 void MidPassToReturn();

 void LastOrder();
 void LastPassToReturn();

 void LevelOrder();

protected:
private:
 struct Infor *m_pHead, *m_pTail, *m_Root;
};

Test::Test()
{
 m_Root = NULL;
 m_pTail = m_pHead = new struct Infor;
 m_pHead->next = NULL;
}

static int CreatTrees(struct Infor *p, int k)
{
 char  word;
 struct Infor *q = NULL;
 cin >> word;
 if ('0' != word)
 {
  if (NULL == (q = new struct Infor))
  {
   return 0;
  }

  q->word = word;
  q->lchild = NULL;
  q->rchild = NULL;
  q->next   = NULL;

  if (1 == k)
  {
   p->lchild = q;
  }
  if (2 == k)
  {
   p->rchild = q;
  }

  CreatTrees(q, 1);
  CreatTrees(q, 2);
 }

 return 0;
}

void Test::CreatTree()
{
 struct Infor *p = NULL;
 char  word;

 cin >> word;

 if ('0' == word)
 {
  return;
 }

 if (NULL == (p = new struct Infor))
 {
  return;
 }

 p->word = word;
 p->lchild = NULL;
 p->rchild = NULL;

 m_Root = p;

 CreatTrees(p, 1);
 CreatTrees(p, 2);

 return;
}

static int PreOrders(struct Infor *p)
{
 if (NULL != p)
 {
  cout << p->word << " ";
  PreOrders(p->lchild);
  PreOrders(p->rchild);
 }
 return 0;
}

void Test::PreOrder()
{
 struct Infor *p = NULL;
 p = m_Root;
 PreOrders(p);
 
 cout << endl;
}

//前序遍历的非递归算法
static int PrePassToReturns(struct Infor *p)
{
 int nTop = -1;
 const int MaxSize = 100;
 struct Infor *q = NULL;
 struct Infor *Q[MaxSize];
 
 while (NULL != p || -1 != nTop)
 {
  while (NULL != p)
  {
   cout << p->word << " ";
   Q[++nTop] = p;
   p = p->lchild;
  }
  
  if (-1 != nTop)
  {
   p = Q[nTop--];
   p = p->rchild;
  }
 }
 
 return 0;
}

void Test::PrePassToReturn()
{
 struct Infor *p = m_Root;
 PrePassToReturns(p);
 
 cout << endl;
}
static int MidOrders(struct Infor *p)
{
 if (NULL != p)
 {
  MidOrders(p->lchild);
  cout << p->word << " ";
  MidOrders(p->rchild);
 }

 return 0;
}

void Test::MidOrder()
{
 struct Infor *p = m_Root;
 MidOrders(p);
 cout << endl;
}

//中序遍历的非递归算法
static int MidPassToReturns(struct Infor *p)
{
 int nTop = -1;
 const int MaxSize = 100;
 struct Infor *Q[MaxSize];

 while (NULL != p || -1 != nTop)
 {

  while (NULL != p)
  {
   Q[++nTop] = p;
   p = p->lchild;
  }

  if (-1 != nTop)
  {
   p = Q[nTop--];
   cout << p->word << " ";
   p = p->rchild;
  }
 }
 return 0;
}
void Test::MidPassToReturn()
{
 struct Infor *p = m_Root;
 MidPassToReturns(p);

 cout << endl;

}

static int LastOrders(struct Infor *p)
{
 if (NULL != p)
 {
  LastOrders(p->lchild);
  LastOrders(p->rchild);
  cout << p->word << " ";
 }
 return 0;
}
void Test::LastOrder()
{
 struct Infor *p = m_Root;
 LastOrders(p);
 cout << endl;
}

//后续遍历的非递归算法
static int LastPassToReturns(struct Infor *p)
{
 int    nTop = -1;
 const int  MaxSize = 100;
 struct Infor *Q[MaxSize];
 struct Infor *q = NULL;

//  while (NULL != p || -1 != nTop)
//  {
//   while (NULL != p)     //得到左子树的叶子节点
//   {
//    Q[++nTop] = p;
//    Q[nTop]->nFlags = 1;
//    p = p->lchild;
//   }
//
//   while (-1 != nTop && 2 == Q[nTop]->nFlags)
//   {
//    p = Q[nTop--];
//    cout << p->word << " ";
//   }
//
//   if (-1 != nTop)
//   {
//    Q[nTop]->nFlags = 2;
//    p = Q[nTop]->rchild;
//   }
//
//   if (-1 != nTop && NULL != p)
//   {
//    break;
//   }
//   }

 return 0;
}

void Test::LastPassToReturn()
{
 struct Infor *p = m_Root;
 LastPassToReturns(p);
 cout << endl;
}

//层序遍历算法
static int LevelOrders(struct Infor *p)
{
 const int MaxSize = 100;
 int front = 0, rear = 0;
 struct Infor *q = NULL;
 struct Infor *Q[MaxSize];

 if (NULL == p)
 {
  return 0;
 }
 else
 {
  Q[rear++] = p;
  while (front != rear)
  {
   q = Q[front++];
   cout << q->word << " ";

   if (NULL != q->lchild)
   {
    Q[rear++] = q->lchild;
   }

   if (NULL != q->rchild)
   {
    Q[rear++] = q->rchild;
   }
  }
 }
 return 0;
}

void Test::LevelOrder()
{
 struct Infor *p = m_Root;
 LevelOrders(p);
 
 cout << endl;
}

int main()
{
 freopen("1.txt", "r", stdin);
 Test t;
 t.CreatTree();

 cout << "PreOrder" << endl;
 t.PreOrder();

 cout << "MidOrder" << endl;
 t.MidOrder();

 cout << "LevelOrder" << endl;
 t.LevelOrder();

 cout << "PrePassToReturn" << endl;
 t.PrePassToReturn();

 cout << "MidPassToReturn" << endl;
 t.MidPassToReturn();

 cout << "LastOrder" << endl;
 t.LastOrder();

// cout << "LastPassToReturns" << endl;
// t.LastPassToReturn();
 return 0;

}