二叉树的递归与非递归遍历

• 遍历时对树的一种基本运算，所为遍历二叉树就是按一定的规则和顺序走遍二叉树的所有节点，是每一个节点都被访问一次，有且只被访问一次。由于二叉树是非线性结构，因此，树的遍历实质上是将二叉树的各个节点转化为一个现行序列来表示。
• 下面的代码就是实现树的遍历的递归与非递归遍历的，还补充了一些常用递归求解的常见问题。

#include<iostream>
#include<stack>
#include<queue>
using namespace std;
typedef char elemtype;

//二叉树节点形式
typedef struct BTreeNode
{
	elemtype data;
	struct BTreeNode *left;
	struct BTreeNode *right;
}BtNode;

//为二叉树节点申请空间
BTNode *BuyNode(int val)
{
	BtNode *s = (BtNode*)malloc(sizeof(BtNode));
	s->data = val;
	s->left = NULL;
	s->right = NULL;
	return s;
}

//创造一颗二叉树
//根据数组来创建一颗二叉树
BtNode *CreateTree(char *arr, int len, int i)
{
	BtNode *s = NULL;
	if(i  < n)
	{
		s = BuyNode(arr[i]);
		s->left = CreateTree(arr, len, 2 * i);
		s->right = CreateTree(arr, len, 2 * i + 1);
	}
	return s;
}
BtNode *CreateTreeArr(char *arr, int len)
{
	if(arr == NULL || len <= 0)
	{
		return NULL;
	}
	return CreateTree(arr, len, 0);
}

//根据二叉树的先序和中序创建树
BtNode *CreatePI(char *ps, char *is, int len)
{
	BtNode *s = NULL;
	if(len > 0)
	{
		s = BuyNode(ps[0]);
		int pos = -1;
		for(int i = 0; i < len; i++)
		{
			if(ps[0] == is[i])
			{
				pos = i;
				break;
			}
		}
		if(pos == -1)
		{
			return NULL;
		}
		s->left = CreatePI(ps + 1, is, pos);
		s->right = CreatePI(ps + pos + 1, is + pos + 1, len - pos - 1);
	}
	return s;
}
BtNode *CreateTreePI(char *ps, char *is, int len)
{
	if(ps == NULL || is == NULL || len <= 0)
	{
		return NULL;
	}
	return CreatePI(ps, is, len);
}

//根据中序和后序来创建一颗二叉树
BtNode *CreateLI(char *ls, char *is, int len)
{
	BtNode *s = NULL;
	if(len > 0)
	{
		s = BuyNode(ls[len - 1]);
		int pos = -1;
		for(int i = 0; i < len; i++)
		{
			if(is[i] == ls[len - 1])
			{
				pos = i;
				break;
			}
		}
		if(pos == -1)
		{
			return NULL;
		}
		s->left = CreateLI(ls, is, pos);
		s->right = CreateLI(ls + pos, is + pos + 1, len - pos - 1);
	}
	return s;
}
BtNode *CreateTreeLI(char *ls, char *is, int len)
{
	if(ls == NULL || is == NULL || len <= 0)
	{
		return NULL;
	}
	return CreateLI(ls, is, len);
}

//二叉树的遍历
//递归的先序遍历
void  PreOrder(BtNode *ptree)
{
	if(ptree == NULL)
	{
		return;
	}
	cout << ptree->data << " ";
	PreOrder(ptree->left);
	PreOrder(ptree->right);
}
//非递归的先序遍历
void NicePreOrder(BtNode *ptree)
{
	if(ptree == NULL)
	{
		return;
	}
	stack<BtNode*> st;
	st.push(ptree);
	while(!st.empty())
	{
		ptree = st.top();
		st.pop();
		cout << ptree->data << " ";
		if(ptree->right != NULL)
		{
			st.push(ptree->right);
		} 
		if(ptree->left != NULL)
		{
			st.push(ptree->left);
		}
	}
	cout << endl;
}

//递归的中序遍历
void  InOrder(BtNode *ptree)
{
	if(ptree == NULL)
	{
	 	 return;
	}
	InOrder(ptree->left);
 	cout << ptree->data << " ";
	InOrder(ptree->right);
}
//非递归的中序遍历
void NiceInOrder(BtNode *ptree)
{
	if(ptree == NULL)
	{
		return;
	}
	stack<BtNode*> st;
	while(!st.empty() || ptree != NULL)
	{
		while(ptree)
		{
			st.push(ptree);
			ptree = ptree->left;
		}
		ptree = st.top();
		st.pop();
		cout << ptree->data << " ";
		ptree = ptree->right;
	}
	cout << endl;
}

//递归的后序遍历
void  PastOrder(BtNode *ptree)
{
	if(ptree == NULL)
 	{
  		return;
	}
 	PastOrder(ptree->left);
 	PastOrder(ptree->right);
 	cout << ptree->data << " ";
}
//非递归的后序遍历
void NicePastOrder(BtNode *ptree)
{
	if(ptree == NULL)
	{
		return;
	}
	stack<BtNode *> st;
	BtNode *flag = NULL;
	while(ptree != NULL || st.empty())
	{
		while(ptree != NULL)
		{
			st.push(ptree):
			ptree = ptree->left;
		}
		ptree = st.top();
		st.pop();
		if(ptree->right == NULL || ptree->right == flag)
		{
			cout << ptree->data << " ";
			flag = ptree;
			ptree = NULL;
		}
		else
		{
			st.push(ptree);
			ptree = ptree->right;
		}
	}
}

//二叉树的层序遍历并计算出树的高度
int NiceLevelOrder(BtNode *ptree)
{
	if(ptree == NULL)
	{
		return;
	}
	queue<BtNode *> que;
	int high = 0;
	que.push(ptree);
	while(!que.empty())
	{
		int len = que.size();
		high++;
		while(len--)
		{
			ptree = que.front();
			que.pop();
			cout << ptree->data << " ";
			if(ptree->left != NULL)
			{
				que.push(ptree->left);
			}
			if(ptree->right != NULL)
			{
				que.push(ptree->right);
			}
		}
	}
	return high;
}

//递归法求树的高度
int GetTreeHigh(BtNode *ptree)
{
	if(ptree == NULL)
	{
		return 0;
	}
	return GetTreeHigh(ptree->left) > GetTreeHigh(ptree->right) ? 
	                                  GetTreeHigh(ptree->left) + 1 : GetTreeHigh(ptree->right) + 1;
}