树的遍历总结

树的层序遍历

树的前序，中序，后序遍历的递归和非递归实现。

#include "stdafx.h"
#include<iostream>
#include<stack>
#include<queue>
using namespace std;

namespace Tree
{
	struct TreeNode
	{
		int data;
		struct TreeNode* left;
		struct TreeNode* right;
	};

	int initVal[] = { 1, 2, 4, 255, 255, 5, 255, 255, 3, 6, 255, 255, 7, 255, 255 };
	int index = 0;

	/前序建立树
	TreeNode* createTree()
	{

		if (initVal[index] == 255)
		{
			index++;			//低级错误，少了这一句，导致程序停到了第一个255位置
			return NULL;
		}

		else
		{
			TreeNode* t = (TreeNode*)::operator new(sizeof(TreeNode));
			t->data = initVal[index++];
			t->left = createTree();
			t->right = createTree();
			return t;
		}
	}
	void deleteTree(TreeNode* root)
	{
		if (root == NULL)	return;
		deleteTree(root->left);
		deleteTree(root->right);
		deleteTree(root);
	}

	树的遍历
	//递归层序遍历输出
	void levelOrderTraverse(TreeNode* t)
	{
		if (t != NULL)
		{
			TreeNode* tTemp;
			queue<TreeNode*> tq;
			tq.push(t);
			while (!tq.empty())
			{
				tTemp = tq.front();
				cout << tTemp->data << ' ';
				tq.pop();
				if (tTemp->left != NULL)		tq.push(tTemp->left);
				if (tTemp->right != NULL)	tq.push(tTemp->right);
			}
		}
	}



	//递归前序遍历输出
	void preOrderTraverse(TreeNode* t)
	{
		if (t != NULL)
		{
			cout << t->data << ' ';
			preOrderTraverse(t->left);
			preOrderTraverse(t->right);
		}

	}
	//非递归前序遍历输出
	void preOrderTraverse_NonRecursive(TreeNode* t)
	{
		stack<TreeNode*> s;
		TreeNode* p;
		p = t;
		while (p != NULL || !s.empty())
		{
			while (p != NULL)
			{
				cout << p->data << ' ';
				s.push(p);
				p = p->left;
			}
			if (!s.empty())
			{
				p = s.top();
				s.pop();
				p = p->right;
			}
		}
	}

	//递归中序遍历：
	void inOrderTraverse(TreeNode* t)
	{
		if (t != NULL)
		{
			inOrderTraverse(t->left);
			cout << t->data << ' ';
			inOrderTraverse(t->right);
		}
	}

	//非递归中序遍历：
	void inOrderTraverse_NonRecursive(TreeNode* t)
	{
		stack<TreeNode*> s;
		TreeNode* p = t;
		while (p != NULL || !s.empty())
		{
			while (p != NULL)
			{
				s.push(p);
				p = p->left;

			}
			if (!s.empty())
			{
				p = s.top();
				cout << p->data << ' ';
				s.pop();
				p = p->right;
			}
		}
	}

	//递归后续遍历输出
	void postOrderTraverse(TreeNode* t)
	{
		if (t != NULL)
		{
			postOrderTraverse(t->left);
			postOrderTraverse(t->right);
			cout << t->data << ' ';
		}
	}
	//非递归后续遍历输出
	void postOrderTraverse_NonRecursive(TreeNode* t)
	{
		stack<TreeNode*> s;
		TreeNode* p;
		TreeNode* tPre = NULL;
		s.push(t);
		while (!s.empty())
		{
			p = s.top();
			if ((NULL == p->left&&NULL == p->right) || (tPre != NULL && (tPre == p->left || tPre == p->right)))
			{
				cout << p->data << ' ';
				s.pop();
				tPre = p;
			}
			else
			{
				if (p->right != NULL)	s.push(p->right);
				if (p->left != NULL)		s.push(p->left);
			}

		}
	}
	void testTree()
	{
		TreeNode* root = createTree();
		cout << endl << "层序遍历结果：" << endl;
		levelOrderTraverse(root);

		cout << endl << "非递归前序遍历结果：" << endl;
		preOrderTraverse_NonRecursive(root);

		cout << endl << "递归前序遍历结果：" << endl;
		preOrderTraverse(root);

		cout << endl << "非递归中序遍历结果：" << endl;
		inOrderTraverse_NonRecursive(root);

		cout << endl << "递归中序遍历结果：" << endl;
		inOrderTraverse(root);
		cout << endl << "递归后续遍历结果：" << endl;
		postOrderTraverse(root);
		cout << endl << "非递归后续遍历结果：" << endl;
		postOrderTraverse_NonRecursive(root);
		deleteTree(root);
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	Tree::testTree();
	cout << endl;
	return 0;
}

运行结果：