二叉树的遍历

先序遍历

1. 访问根结点
2. 先序遍历左子树
3. 先序遍历右子树
   递归实现

void PreOrderTraversal(BinTree bt)
{
	if(bt)
	{
		cout<<bt->data;
		PreOrderTraversal(bt->left);
		PreOrderTraversal(bt->right);
	}
}

非递归实现
使用栈

1. 遇到一个结点，访问其并就将它压入栈中
2. 先序遍历其左子树
3. 当左子树遍历完后，从栈中弹出一个结点，先序遍历其右子树

void PreOrderTraversal(BinTree bt)
{
	stack<BinTree>s;
	BinTree b=bt;
	while(b||s.size())
	{
		while(b)
		{
			cout<<b->data;
			s.push(b);
			b=b->left;
		}
		if(s.size())
		{
			b=s.top();
			s.pop();			
			b=b->right;
		}
	}
}

中序遍历

1. 中序遍历其左子树
2. 访问根结点
3. 中序遍历其右子树
   递归实现

void InOrderTraversal(BinTree bt)
{
	if(bt)
	{
		InOrderTraversal(bt->left);
		cout<<bt->data;
		InOrderTraversal(bt->right);		
	}
}

非递归实现
使用栈

1. 遇到一个结点，就将它压入栈中，并去中序遍历它的左子树
2. 当左子树遍历结束后，从栈顶弹出一个结点访问其
3. 中序遍历该结点的右子树

void InOrderTraversal(BinTree bt)
{
	stack<BinTree>s;
	BinTree b=bt;
	while(b||s.size())
	{
		while(b)
		{
			s.push(b);
			b=b->left;
		}
		if(s.size())
		{
			b=s.top();
			s.pop();
			cout<<b->data;
			b=b->right;
		}
	}
}

后序遍历

1. 后序遍历其左子树
2. 后序遍历其右子树
3. 访问根结点
   递归实现

void PostOrderTraversal(BinTree bt)
{
	if(bt)
	{
		PostOrderTraversal(bt->left);
		PostOrderTraversal(bt->right);
		cout<<bt->data;
	}
}

非递归实现
使用两个栈
按照反序将需要访问的内容压入另一个栈中

void PostOrderTraversal(BinTree bt)
{
	stack<BinTree>s;
	stack<BinTree>ss;
	BinTree b=bt;
	while(b||s.size())
	{
		while(b)
		{
			s.push(b);
			ss.push(b);
			b=b->right;
		}		
		if(s.size())
		{
			b=s.top();
			s.pop();		
			b=b->left;	
		}
	}
	while(ss.size())
	{
		b=ss.top();
		ss.pop;
		cout<<b->data;
	}
}

层序遍历

逐层按顺序遍历
队列实现

1. 从队列中取出一个元素
2. 访问该元素
3. 若该元素的左右结点非空，将其加入队列

void LevelOrderTraversal(BinTree bt)
{
	queue<BinTree>q;
	BinTree t=bt;
	q.push(t);
	while(q.size())
	{
		t=q.front();
		q.pop();
		cout<<t->data;
		if(t->left)
			q.push(t->left);
		if(t->right)
			q.push(t->right);
	}
}