跟左神一起练算法（非递归实现二叉树的遍历）

前序遍历：

void xianxubianli(TreeNode*& tree)
{
	if (tree == nullptr)
		return;
	stack<TreeNode*> sta;
	sta.push(tree);
	while (!sta.empty())
	{
		tree = sta.top();
		sta.pop();
		cout << tree->value << " ";
		if (tree->right != nullptr)
			sta.push(tree->right);
		if (tree->left != nullptr)
			sta.push(tree->left);
	}
}

非递归前序遍历：
使用一个栈：
1.当树是空的时候直接返回空
2.先给栈中压入树的一个节点
3.在栈不为空的情况下，先弹出并打印一个结点，在将这个节点的右，左结点在不为空的情况下依次压入栈，循环起来，直到栈为空

====================================================================================

中序遍历：

#include<iostream>
#include<stack>
using namespace std;
template<class T>
struct TreeNode
{
	TreeNode(int c = 0)
	:value(c)
	, left(nullptr)
	, right(nullptr)
	{}
	TreeNode<T>* left;
	TreeNode<T>* right;
	T value;
};
template<class T>
void 中序遍历(TreeNode<T>*& tree)
{
	if (tree != nullptr)
	{
		stack<TreeNode<T>*> sta;
		while (!sta.empty() || tree != nullptr)
		{
			if (tree != nullptr)
			{
				sta.push(tree);
				tree = tree->left;
			}
			else
			{
				tree = sta.top();
				sta.pop();
				cout << tree->value << " ";
				tree = tree->right;
			}
		}
	}
}
int main()
{
	TreeNode<int>* tree = new TreeNode<int>;
	TreeNode<int>* right1 = new TreeNode<int>(1);
	TreeNode<int>* left1 = new TreeNode<int>(2);
	TreeNode<int>* right2 = new TreeNode<int>(3);
	TreeNode<int>* left2 = new TreeNode<int>(4);
	TreeNode<int>* right3 = new TreeNode<int>(5);
	TreeNode<int>* left3 = new TreeNode<int>(6);
	tree->left = left1;
	tree->right = right1;
	left1->left = left2;
	left1->right = right2;
	right1->left = left3;
	right1->right = right3;
	中序遍历(tree);
	return 0;
}

结果：

1.在栈不为空或者当前结点不为空的时候，循环进行
2.在当前节点不为空的时候，就不断往栈中压入左节点，
3.在当前结点为空的时候，将栈顶元素弹出，并且在弹出节点右结点不为空的情况下压入右结点，
4直到栈为空，并且树为空结束循环，
弹出即打印

===================================================================================
后序遍历代码：

#include<iostream>
#include<stack>
using namespace std;
template<class T>
struct TreeNode
{
	TreeNode(int c = 0)
	:value(c)
	, left(nullptr)
	, right(nullptr)
	{}
	TreeNode<T>* left;
	TreeNode<T>* right;
	T value;
};
template<class T>
void 后序遍历(TreeNode<T>*& tree)
{
	if (tree == nullptr)
		return;
	stack<TreeNode<T>*> sta;
	stack<TreeNode<T>*> sta1;
	sta.push(tree);
	while (!sta.empty())
	{
		tree = sta.top();
		sta.pop();
		sta1.push(tree);
		if (tree->left != nullptr)
			sta.push(tree->left);
		if (tree->right != nullptr)
			sta.push(tree->right);
	}
	while (!sta1.empty())
	{
		cout << sta1.top()->value<<" ";
		sta1.pop();
	}
}
int main()
{
	TreeNode<int>* tree = new TreeNode<int>;
	TreeNode<int>* right1 = new TreeNode<int>(1);
	TreeNode<int>* left1 = new TreeNode<int>(2);
	TreeNode<int>* right2 = new TreeNode<int>(3);
	TreeNode<int>* left2 = new TreeNode<int>(4);
	TreeNode<int>* right3 = new TreeNode<int>(5);
	TreeNode<int>* left3 = new TreeNode<int>(6);
	tree->left = left1;
	tree->right = right1;
	left1->left = left2;
	left1->right = right2;
	right1->left = left3;
	right1->right = right3;
	后序遍历(tree);
	return 0;
}

后序遍历是由前序遍历推来的

对于二叉树的遍历：时间复杂度是节点的个数，空间复杂度是树的高度（因为存在不断地压入弹出，最大也就是树的高度）

递归版本是操作系统给你进行函数栈，非递归版本是自己提供的栈，都是用额外空间的
也有办法可以将二叉树的遍历，空间复杂度压缩到o（1）