- 前序 遍历（非递归算法,利用栈）

• 给定一个二叉树，返回它的 前序 遍历（非递归算法）

typedef struct TreeNode* STDataType;

typedef struct Stack{
 STDataType *_a;
 int _top;
 int _capacity;
 }Stack;
Stack ps;

void StackInit(Stack* ps){
 assert (ps);
 ps->_a = NULL;
 ps->_top = 0;
 ps->_capacity = 0;}
 
void StackDestory(Stack* ps){
 assert (ps);
 free(ps->_a);
 ps->_a = NULL;
 ps->_top = 0;
 ps->_capacity = 0;}
 
void StackPush(Stack* ps, STDataType x){
  assert (ps);
  if (ps->_top==ps->_capacity)
  {
    int newcapacity = pa->_capacity==0 ? 4 : 2*(ps->_capacity);
    ps->_a=(STDataType*)malloc(mewcapacity*sizeof(STDataType));
    assert (ps->_a);
    ps->_capacity = newcapacity;
  }
  ps->_a[ps->_top] = x;
  ps->top++;
 }
 
void StackPop(Stack* ps){
 assert (ps && ps->top>0);
 ps->_top--;
 }
 
STDataType StackTop(Stack* ps){
  assert (ps && ps->_top>0);
  return ps->_a[ps->_top-1];
  }
  
int StackEmpty(Stack* ps){
 assert (ps);
 return ps->_top==0 ? 0 : 1;
 }
 
int StackSize(Stack* ps){
  assert (ps);
  return ps->_top;
 }

int* preorderTraversal(struct TreeNode* root, int* returnSize){
  Stack st;//利用栈，对二叉树实现遍历
  StackInit (&st);
  struct TreeNode* cur = root;
  
  while (StackEmpty(&st)!=0 || cur!=NULL){
    while (cur!=NULL){
      (*returnSize)++;//算结点的个数，为数组的开辟做准备。
      StackPush(&st,cur);
      cur = cur->left;
     }
  struct TreeNode* top = StackTop(&st);
  StackPop(&st);
  //遍历右子树。
  cur = top->right;
 }

  int *prearray = (int*)malloc(4*sizeof(*returnSize));  //给数组开辟空间
  //要利用每一个节点的大小，不能用（sizeof(STDataType)）
  cur = root;
  int i=0;
  while (StackEmpty(&st)!=0 || cur!=NULL){
   while (cur!=NULL){
    prearray[i] = cur->val;
    i++；//
    StackPush(&st,cur);
    cur = cur->left;
   }
  struct TreeNode* top = StackTop(&st);
  StackPop(&st);
  cur = top->left;
 }
 return prearray;
}