常用数据结构---非递归中序遍历二叉树(利用栈)

// Tree.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
using namespace std;
const int STACKSIZE = 10;
const int INCREASEMENT = 10;

enum Symbol
{
 Success,
 Fail
};

//TreeNode
typedef struct tagTreeNode
{
 int n;
 struct tagTreeNode *pLeft,*pRight;  //二叉树的左子树右子树
}TreeNode_S;

//typedef int Elemtype;
//Stack 数据结构
typedef struct tagStack
{
 int nStackSize;
 TreeNode_S *pBase,*pTop;
}Stack_S;

//初始化栈
int InitStack(Stack_S &Stack)
{
 Stack.pBase = (TreeNode_S *)malloc(STACKSIZE*sizeof(TreeNode_S));
 if (Stack.pBase == NULL)
 {
  return Fail;
 }
 Stack.pTop = Stack.pBase; //空栈
 Stack.nStackSize = STACKSIZE;
 return Success;
}

//判断是否空栈
bool StackEmpty(Stack_S Stack)
{
 if (Stack.pBase == Stack.pTop)
 {
  return true;
 }
 else
  return false; 
}

//在用动态数组实现的栈中，如果栈的空间不够用时，我们用realloc运行时动态增加了空间，
//这时指向原空间栈底的指针会伴随着使用realloc而自动更新，
//但是指向原空间栈顶的指针却不会自动更新到新空间去，这时我们就必须手动更新这个栈顶指针了！
//realloc 并不保证返回和原来一样的地址..无论调用几次 realloc,最后我们只需一次 free。

//进栈
int PushStack(Stack_S &Stack, TreeNode_S *TreeNode)
{
 if (Stack.pTop - Stack.pBase >= Stack.nStackSize - 1) //申请空间
 {
  Stack.pBase = (TreeNode_S *)realloc(Stack.pBase, (Stack.nStackSize + INCREASEMENT)*sizeof(TreeNode_S));
  Stack.pTop = Stack.pBase + Stack.nStackSize - 1;  //使用realloc必须重设top指针
  Stack.nStackSize += INCREASEMENT;
 }
 *Stack.pTop++ = *TreeNode;
 return Success;
}

//出栈
int PopStack(Stack_S &Stack, TreeNode_S *TreeNode)
{
 if (Stack.pBase == Stack.pTop)
 {
  return Fail;
 }
 *TreeNode = *--Stack.pTop;
 return Success;
}

int _tmain(int argc, _TCHAR* argv[])
{
 Stack_S StackObj;  //栈对象
 //初始化二叉树
 TreeNode_S *pTreeNode1 = new TreeNode_S;
 pTreeNode1->n = 1;
 pTreeNode1->pLeft = NULL;
 pTreeNode1->pRight = NULL;
 TreeNode_S *pTreeNode2 = new TreeNode_S;
 pTreeNode2->n = 2;
 pTreeNode2->pLeft = NULL;
 pTreeNode2->pRight = NULL;
 TreeNode_S *pTreeNode3 = new TreeNode_S;
 pTreeNode3->n = 3;
 pTreeNode3->pLeft = NULL;
 pTreeNode3->pRight = NULL;
 TreeNode_S *pTreeNode4 = new TreeNode_S;
 pTreeNode4->n = 4;
 pTreeNode4->pLeft = NULL;
 pTreeNode4->pRight = NULL;

 //建树
 pTreeNode1->pLeft = pTreeNode2;
 pTreeNode1->pRight = pTreeNode3;
 pTreeNode2->pRight = pTreeNode4;

 TreeNode_S *TreeNodeTemp = pTreeNode1;  //根结点

 //调用栈中序遍历树（非递归）
 InitStack(StackObj);
 while (TreeNodeTemp || !StackEmpty(StackObj))
 {
  if (TreeNodeTemp)
  {
   PushStack(StackObj, TreeNodeTemp);
   TreeNodeTemp = TreeNodeTemp->pLeft;
  }
  else
  {
   //TreeNode_S TreeNodeTemp;
   TreeNode_S *pTreeNode = new TreeNode_S;
   PopStack(StackObj, pTreeNode);
   cout<<pTreeNode->n<<endl;
   TreeNodeTemp = pTreeNode;
   TreeNodeTemp = TreeNodeTemp->pRight;
   delete pTreeNode;
   pTreeNode = NULL;
  }
 }

 //释放资源
 if (pTreeNode1)
 {
  delete pTreeNode1;
  pTreeNode1 = NULL;
 }
 if (pTreeNode2)
 {
  delete pTreeNode2;
  pTreeNode2 = NULL;
 }
 if (pTreeNode3)
 {
  delete pTreeNode3;
  pTreeNode3 = NULL;
 }
 if (pTreeNode4)
 {
  delete pTreeNode4;
  pTreeNode4 = NULL;
 }
 if (StackObj.pBase)
 {
  free(StackObj.pBase);
  StackObj.pBase = NULL;
  StackObj.pTop = NULL;
 }

 system("pause");
 return 0;
}