二叉树遍历（前序遍历、中序遍历、后序遍历、层次遍历）C/C++

二叉树的遍历方式有四种：遍历的时候记住，左子树一定是先于右子树遍历的，根最先遍历就是先序遍历，根在中间就是中序遍历，根在最后遍历就是后序遍历。并且，遍历左子树和右子树的时候，遍历的方式也是遵循大的遍历规则，比如二叉树遍历方式为先序遍历，那么左子树和右子树遍历的时候，也是按照这种方式进行遍历。

1. DLR – 先序遍历：（先根遍历）先根  再左  再右
2. LDR – 中序遍历：（中根遍历）先左  再根  再右
3. LRD – 后序遍历：（后跟遍历）先左  再右  再根
4. 层次遍历 –        ：一层一层往下遍历（这个用的比较少）

对于上面这棵二叉树，它的遍历结果为：

先序遍历：ABDECFG

中序遍历：DBEAFCG

后续遍历：DEBFGCA

层次遍历：ABCDEFG

 

二叉树自身具有递归特性，所以可以利用递归对二叉树进行遍历。

先定义一个结构体：

//二叉树节点结构体
typedef struct BinaryTreeNode
{
	char data;  //数据 假设为char类型
	struct BinaryTreeNode*left;  //左孩子节点
	struct BinaryTreeNode*right;  //右孩子节点
}Node;

一、先序遍历

//先序遍历
void preOrder(const Node*root)
{
	if (NULL == root)
	{
		return;
	}

	printf("%c ", root->data);
	preOrder(root->left);
	preOrder(root->right);
}

二、中序遍历

//中序遍历
void inOrder(const Node*root)
{
	if (NULL == root)
	{
		return;
	}

	
	inOrder(root->left);
	printf("%c ", root->data);
	inOrder(root->right);
}

三、后序遍历

//后序遍历
void  laOrder(const Node *root)
{
	if (NULL == root)
	{
		return;
	}

	laOrder(root->left);
	laOrder(root->right);
	printf("%c ", root->data);
}

综合三种遍历方式，发现在递归的方式中

laOrder(root->left);
laOrder(root->right);
printf("%c ", root->data);  //这条语句在第一行就是先序遍历，中间就是中序遍历，最后就是后序遍历

四、层次遍历

因为层次遍历是从上到下，从左到右 逐行遍历的，这种类型为广度遍历。而前三个遍历方式，为深度遍历。所以对于层次遍历不建议用递归的方式。但是为了统一，我这里也写一个递归的层次遍历。

//层次遍历
void leOrder(const Node *root,const int depth,int once = 0)
{
	if (NULL == root || 0 == depth)
	{
		return;
	}
	
	if(once)
		printf("%c ", root->data);
	if (NULL != root->left)
		printf("%c ", root->left->data);
	if (NULL != root->right)
		printf("%c ", root->right->data);
	leOrder(root->left, depth - 1);
	leOrder(root->right, depth - 1);
	
}

这个递归看上去也挺像的。

 

看一下自己的main函数，测试的代码：

int main()
{
	//准备数据
	Node nodeA = { 'A',NULL,NULL };
	Node nodeB = { 'B',NULL,NULL };
	Node nodeC = { 'C',NULL,NULL };
	Node nodeD = { 'D',NULL,NULL };
	Node nodeE = { 'E',NULL,NULL };
	Node nodeF = { 'F',NULL,NULL };
	Node nodeG = { 'G',NULL,NULL };

	//建立关系
	nodeA.left = &nodeB;
	nodeA.right = &nodeC;

	nodeB.left = &nodeD;
	nodeB.right = &nodeE;

	nodeC.left = &nodeF;
	nodeC.right = &nodeG;


	//调用递归函数
	preOrder(&nodeA);
	printf("\n");
	inOrder(&nodeA);
	printf("\n");
	laOrder(&nodeA);
	printf("\n");
	leOrder(&nodeA,3,1);
	printf("\n");


	system("pause");
	return 0;
}

运行的结果也看一下：

 

递归挺占用资源的，所以可以用栈的方式实现前、中、后序遍历，用队列或者数组什么的实现层次遍历。这个实现后面在写了。