二叉树遍历（C++实现）

二叉树3种深度优先遍历（递归、非递归）、层次遍历，最简洁、最好记！

#include<iostream>
#include<stack>
#include<queue>

using namespace std;
//节点定义
struct Node
{
	char data;
	Node *left;
	Node *right;

	Node(const char &Data, Node *Left = NULL, Node *Right = NULL)
	{
		data = Data;
		left = Left;
		right = Right;
	}
};
//先序遍历（递归）
void pre_order_recursive(Node *root)
{
	if (root == NULL)
		return;
	cout << root->data << " ";
	pre_order_recursive(root->left);
	pre_order_recursive(root->right);
}
//中序遍历（递归）
void mid_order_recursive(Node *root)
{
	if (root == NULL)
		return;
	mid_order_recursive(root->left);
	cout << root->data << " ";
	mid_order_recursive(root->right);
}
//后序遍历（递归）
void post_order_recursive(Node *root)
{
	if (root == NULL)
		return;
	post_order_recursive(root->left);
	post_order_recursive(root->right);
	cout << root->data << " ";
}
//先序遍历
void pre_order(Node *root)
{
	if (root == NULL)
		return;
	stack<Node*> s;
	s.push(root);
	Node *p = NULL;
	while (!s.empty())
	{
		p = s.top();
		cout << p->data << " ";
		s.pop();
		if (p->right)
			s.push(p->right);
		if (p->left)
			s.push(p->left);
	}
}
//中序遍历
void mid_order(Node *root)
{
	if (root == NULL)
		return;
	stack<Node*> s;
	Node *p = root;
	while (p != NULL || !s.empty())
	{
		while (p != NULL)
		{
			s.push(p);
			p = p->left;
		}
		p = s.top();
		cout << p->data << " ";
		s.pop();
		p = p->right;
	}
}
//后序遍历
void post_order(Node *root)
{
	if (root == NULL)
		return;
	stack<Node*> s;
	Node *p = root, *r = NULL;
	while (p != NULL || !s.empty())
	{
		while (p != NULL)
		{
			s.push(p);
			p = p->left;
		}
		p = s.top();
		if (p->right&&p->right != r)
		{
			p = p->right;
		}
		else
		{
			cout << p->data << " ";
			s.pop();
			r = p;
			p = NULL;
		}
	}
}
//层次遍历
void layer_order(Node *root)
{
	if (root == NULL)
		return;
	queue<Node*> q;
	q.push(root);
	Node *p = NULL;
	while (!q.empty())
	{
		p = q.front();
		cout << p->data << " ";
		q.pop();
		if (p->left)
			q.push(p->left);
		if (p->right)
			q.push(p->right);
	}
}

void main()
{
	Node *A = new Node('A');
	Node *B = new Node('B');
	Node *C = new Node('C');
	Node *D = new Node('D');
	Node *E = new Node('E');

	A->left = B;
	A->right = C;
	B->right = D;
	D->left = E;

	cout << "先序遍历-递归:";
	pre_order_recursive(A);
	cout << endl;

	cout << "中序遍历-递归:";
	mid_order_recursive(A);
	cout << endl;

	cout << "后序遍历-递归:";
	post_order_recursive(A);
	cout << endl;

	cout << "先序遍历-非递归:";
	pre_order(A);
	cout << endl;

	cout << "中序遍历-非递归:";
	mid_order(A);
	cout << endl;

	cout << "后序遍历-非递归:";
	post_order(A);
	cout << endl;

	cout << "层次遍历:";
	layer_order(A);
	cout << endl;

	delete A; delete B; delete C; delete D; delete E;
	getchar();
	return;
}

 二叉树：

 输出：