二叉树的递归遍历和层序遍历（c/c++）

• 递归遍历：

二叉树的三种递归遍历为先序遍历，中序遍历和后续遍历。它们相似之处在于都是对二叉树的递归遍历且对任何一个结点都经过三次，区别之处在于哪一次对该结点进行访问，由此分为先，中，后序遍历。所以对于任一结点都有：三次经过，一次访问。

先序遍历：

仅以先序遍历为例说明其思路。

当我们对二叉树进行遍历时，先对该结点内的数据进行访问，然后依次遍历它的左右孩子结点，递归进行直至结束。

例：对一个有三个结点的二叉树，包含根结点A，左孩子结点B和右孩子结点C。先序遍历的函数执行过程如下：（下面的字母和数字表示函数的执行步骤）

第一次函数调用：A，访问根结点中的数据，递归调用左孩子结点B，递归调用右孩子结点C。

第二次函数调用左孩子结点 B：访问左孩子结点内的数据，递归调用左孩子结点的左孩子结点B->left，递归调用左孩子结点的右孩子结点B->right。

第三次函数调用左孩子的左孩子结点B->left：该结点为空，不执行。返回第二次函数调用。

第四次函数调用左孩子的右孩子结点B->right：该结点为空，不执行。返回第二次函数调用。第二次函数调用执行完毕，返回第一次函数调用中。

第五次函数调用右孩子结点 C：访问右孩子结点内数据，递归调用右孩子结点的左孩子结点C->left，递归调用右孩子结点的右孩子结点C->right。

第六次函数调用右孩子的左孩子结点C->left：该结点为空，不执行。返回第五次函数调用。

第七次函数调用右孩子的右孩子结点C->right：该结点为空，不执行。返回第五次函数调用。第五次函数调用执行完毕，返回第一次函数调用。

第一次函数调用执行完毕。递归结束。

void preorder(btNode* p)
{
	if (p != NULL)
	{
		visit(p);
		preorder(p->lc);
		preorder(p->rc);
	}
}

中序遍历：

void inorder(btNode* p)
{
	if (p != NULL)
	{
                inorder(p->lc);
		visit(p);
		inorder(p->rc);
	}
}

后序遍历：

void postorder(btNode* p)
{
	if (p != NULL)
	{
		postorder(p->lc);
		postorder(p->rc);
		visit(p);
	}
}

对于下图中的树：

先序遍历结果为：ABDECF   根   左   右

中序遍历结果为：DBEAFC   左   根   右

后序遍历结果为：DEBFCA   左   右   根

中序与先（后）序可唯一确定一颗二叉树。

• 层序遍历：

二叉树的层序遍历的实现思路：

建立一个辅助数据结构队列，在此采用大小为10的循环队列。初始先将二叉树根节点入队，从而使得队列不为空，接下来进入到循环中，当队列不为空时，队列中元素出队，访问出队元素中的数据，并在出队时将其左右孩子挨个入队，每出队一个结点，将其左右孩子分别入队，直至队列为空，此时所有结点都被访问过了。

void level(btNode* p)
{
	int front, rear;
	front = rear = 0;
	btNode* que[10];//构造一个大小为10的简单循环队列
	if (p != NULL)
	{
		rear = (rear + 1) % 10;
		que[rear] = p;
		while (rear != front)
		{
			front = (front + 1) % 10;
			std::cout << que[front]->data << ' ';//出队时进行输出或进行操作
			if (que[front]->lc != NULL)
			{
				rear = (rear + 1) % 10;
				que[rear] = que[front]->lc;
			}
			if (que[front]->rc != NULL)
			{
				rear = (rear + 1) % 10;
				que[rear] = que[front]->rc;
			}
		}
	}
}

关于树的遍历完整代码如下：

#include<iostream>
typedef struct btNode
{
	char data;//结点中的信息
	struct btNode* lc;//左孩子结点
	struct btNode* rc;//右孩子结点
}btNode;

btNode* initial(char* ele, int num);//用数组初始化一棵树（默认创建一棵完全二叉树）
void preorder(btNode* p);//先序遍历
void inorder(btNode* p);//中序遍历
void postorder(btNode* p);//后续遍历
void level(btNode* p);//层序遍历
int main()
{
	using namespace std;
	char data[6] = { 'a', 'b', 'c', 'd', 'e', 'f' };
	btNode* p = initial(data, 6);

	cout << "先序遍历： ";
	preorder(p);
	cout << endl;

	cout << "中序遍历： ";
	inorder(p);
	cout << endl;

	cout << "后序遍历： ";
	postorder(p);
	cout << endl;

	cout << "层序遍历： ";
	level(p);
	cout << endl;
	return 0;
}
btNode* initial(char* ele, int num)
{
	if (num<1)
		return NULL;
	btNode* temp = new btNode[num];
	int i = 0;
	while (i < num)//将所有结点的左右子树置为空
	{
		temp[i].lc = NULL;
		temp[i].rc = NULL;
		++i;
	}
	i = 0;
	while (i < num/2)//通过完全二叉树的顺序存储来创建树的结构
	{
		if (2*i+1<num)
			temp[i].lc = temp + 2 * i + 1;
		if (2*i+2<num)
			temp[i].rc = temp + 2 * i + 2;
		++i;
	}
	for (i = 0; i < num; i++)//对树中的每个结点赋值
		temp[i].data = ele[i];
	return temp;
}
void preorder(btNode* p)
{
	if (p != NULL)
	{
		std::cout << p->data << ' ';
		preorder(p->lc);
		preorder(p->rc);
	}
}
void inorder(btNode* p)
{
	if (p != NULL)
	{
		inorder(p->lc);
		std::cout << p->data << ' ';
		inorder(p->rc);
	}
}
void postorder(btNode* p)
{
	if (p != NULL)
	{
		postorder(p->lc);
		postorder(p->rc);
		std::cout << p->data << ' ';
	}
}
void level(btNode* p)
{
	int front, rear;
	front = rear = 0;
	btNode* que[10];
	if (p != NULL)
	{
		rear = (rear + 1) % 10;
		que[rear] = p;
		while (rear != front)
		{
			front = (front + 1) % 10;
			std::cout << que[front]->data << ' ';
			if (que[front]->lc != NULL)
			{
				rear = (rear + 1) % 10;
				que[rear] = que[front]->lc;
			}
			if (que[front]->rc != NULL)
			{
				rear = (rear + 1) % 10;
				que[rear] = que[front]->rc;
			}
		}
	}
}

其中数组中的输入为下图中的树：

程序的输出结果为：

二叉树非递归遍历可参考：

二叉树的非递归遍历（c/c++）_Little_ant_的博客-CSDN博客