二叉树的中序遍历（非递归算法）

• 给定一个二叉树，返回它的中序 遍历。

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 = ps->_capacity==0?4:2 * (ps->_capacity);//
		ps->_a= (STDataType*)realloc(ps->_a, newcapacity*sizeof(STDataType));
		assert(ps->_a != NULL);
		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);
	if (ps->_top == 0)
	{
		return 0;
	}
	else
	{
		return 1;
	}
}

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}

int* inorderTraversal(struct TreeNode* root, int* returnSize){
  Stack st;
  StackInit(&st);
  struct TreeNode* cur = root;
  while (StackEmpty(&st)!=0 || cur!=NULL){
   while (cur){
    StackPush(&st,cur);
    (*returnSize)++;
    cur = cur->left;
   }
   struct TreeNode* top = StackTop(&st);
   StackPop(&st);
   cur = cur->right;
  }

 int *array = (int*)malloc(sizeof(int)*(*returnSize));
 cur = root;
 int i = 0;//i要在这次循环的外部定义，否则i的变化每次都是从0开始。
 while (StackEmpty(&st)!=0 || cur!=NULL){
   while(cur!=NULL){
     StackPush(&st,cur);
     cur = cur->left;
   }
  struct TreeNode* top = StackTop(&st);
  cur = root;
  int *array = (int*)malloc(sizeof(int)*(*returnSize));
  array[i++] = top->val;
  StackPop(&st);
  cur = cur->right;
 }
 return array；
}