二叉树遍历的非递归方法

typedef struct node
{
	node* left;
	node* right;
	char   x;

};
struct record{
	node* a;
	int state;
	record(node* a, int state) :a(a), state(state){}
};


void CreateTree(node** root)//先序创建二叉树
{
	char data;
	scanf("%c", &data);

	if (data == '#')
	{
		*root = NULL;
	}
	else
	{
		(*root) = (node*)malloc(sizeof(node));
		(*root)->x = data;
		//printf("%d ", data);
		CreateTree(&(*root)->left);
		CreateTree(&(*root)->right);
	}

}


void MidOrderTree(node* root)
{
	if (root)
	{
		//状态位0，执行第一个递归inorder(cur->left); 	
		MidOrderTree(root->left);
		//状态为1，执行print和inorder(cur->right)
		printf("%c ", root->x);
		MidOrderTree(root->right);
		//状态2，函数结束，返回上层状态 
	}
}

//中序遍历的非递归实现
void non_recursive_inorder(node* root){
	stack<record> s;
	node* cur = root;   //初始化状态 
	int state = 0;
	while (1){		
		if (!cur){//如果遇到null结点，返回上一层 
			if (cur == root)break;//如果没有上一层，退出循环 
			cur = s.top().a;
			state = s.top().state; //返回上层状态 
			s.pop();
		}
		else if (state == 0){    //状态位0，执行第一个递归inorder(cur->left); 	
			s.push(record(cur, 1));//保存本层状态 
			cur = cur->left;        //更新到下层状态  
			state = 0;
		}
		else if (state == 1){      //状态为1，执行print和inorder(cur->right)
			printf("%c ", cur->x); 
			s.push(record(cur, 2));   //保存本层状态 
			cur = cur->right;         //进入下层状态 
			state = 0;
		}
		else if (state == 2){      //状态2，函数结束，返回上层状态 
			if (cur == root)break;  //初始结点的退出状态，遍历结束 
			cur = s.top().a;         //返回上层状态 
			state = s.top().state;
			s.pop();
		}
	}
	putchar(10);
}


void non_recursive_preorder(node* root)
{

	stack<node*>  stack_list;//根节点 左孩子 右孩子
	if (root = NULL)
		return;
	node* ptr = root;
        //本层是左孩子，到了下个顺序，就变成了根节点了
	printf("%c ", ptr->x);
	stack_list.push(root);
	while (!stack_list.empty())
	{
		node* tmp = stack_list.top();//存在一个根节点时，立马就出
		printf("%c ", tmp->x);
		stack_list.pop();

		if (ptr->right)
		{
			stack_list.push(ptr->right);//根据栈的特点，先入后出，所以最后入左孩子
		}

		if (ptr->left)
		{
			stack_list.push(ptr->left);
		}
 //是否等到所以节点都压入栈后，再出//或者等节点压到一定程度后，再出//右节点出的顺序//先序：  根节点  左子树  右子树

	}
}

void non_recursive_midorder(node* root)
{
	if (root == NULL)
		return;
	node* ptr = root;
	stack<node*> stack_list;
	stack_list.push(ptr);
	while (!stack_list.empty())
	{

		while (stack_list.top()->left)
		{			
			stack_list.push(stack_list.top()->left);
		}

		while (!stack_list.empty())//此处用while 不是if;
		{
			node* tmp = stack_list.top();
			printf("%c ", tmp->x);
			stack_list.pop();
			if (tmp->right)//必须要把右边的子树遍历完，才能打印出上面的根，所以，需要压栈
			{
				stack_list.push(tmp->right);
				break;//必须跳出，当做另外一个树处理
			}//否则，继续出栈
				
		}
	}
	
		



}

void non_recursive_postorder(node* root)
{
	stack<node*> stack_list;//左 右 根
	if (root == NULL)
		return;
	stack_list.push(root);
	node* lastnode = NULL;
	while (!stack_list.empty())
	{

		while (stack_list.top()->left)
			stack_list.push(stack_list.top()->left);

		while (!stack_list.empty())
		{
			node* tmp = stack_list.top();
			if (tmp->right == NULL || tmp->right == lastnode)
			{
				printf("%c ", tmp->x);
				lastnode = tmp;
				stack_list.pop();
			}
			else
			{
				stack_list.push(tmp->right);
				break;
			}
			
		}

	}


}