带你理解二叉树的前、中、后、层序遍历

一、二叉树的遍历

1.1前序、中序以及后序遍历

学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的结点进行相应的操作，并且每个结点只操作一次。访问结点所做的操作依赖于具体的应用问题。 遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。

1.2二叉树的遍历

1.2.1 前序、中序以及后序遍历

学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的结点进行相应的操作，并且每个结点只操作一次。访问结点所做的操作依赖于具体的应用问题。 遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。

// 二叉树前序遍历 
void PreOrder(BTNode* root);
// 二叉树中序遍历
void InOrder(BTNode* root);
// 二叉树后序遍历
void PostOrder(BTNode* root);

下面为二叉树前序遍历的遍历图和递归图：

 

为了方便理解在遍历时把空指针的结点一起打印出来

1.3前、中、后序的代码实现遍历

1.3.1前序遍历

void PreOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL");
		return;
	}
	printf("%d ",root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

 1.3.2中序遍历

void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL");
		return;
	}
	PreOrder(root->left);
	printf("%d ",root->data);
    PreOrder(root->right);
}

1.3.3后序遍历

void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL");
		return;
	}
	PreOrder(root->left);
	PreOrder(root->right);
	printf("%d ", root->data);
}

二、层序遍历

层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根结点所在层数为1，层序遍历就是从所在二叉树的根结点出发，首先访问第一层的树根结点，然后从左到右访问第2层上的结点，接着是第三层的结点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

层序的遍历不同与前、中、后序遍历，它需要用到队列。

核心思想：创建一个队列，然后把根结点的指针进入队列。然后队头元素出队，再入队（出对元素的左右非空结点的指针）指针。入队结束就再重复（出队和入对）的循环直到队伍为空；

// 层序遍历
void LevelOrder(BTNode* root);

需要先创造队列函数，下面是函数的声明

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>

//定义类型
typedef struct BinaryTreeNode* QDataType;//设置队列结点的数据类型为二叉树指针
//定义队列结点结构
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;
//定义队列的头指针和尾指针
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;
//初始化队列
void QueueInit(Queue* pq);
//销毁队列
void QueueDestroy(Queue* pq);
//入队
void QueuePush(Queue* pq,QDataType x);
//出队
void QueuePop(Queue* pq);
//返回队列的个数
int QueueSize(Queue* pq);
//检查队列是否为空
bool QueueEmpty(Queue* pq);
//返回头结点的数据
QDataType QueueFront(Queue* pq);
//返回尾结点的数据
QDataType QueueBack(Queue* pq);
//打印队列的全部元素
void QueuePrint(Queue* pq);

队列函数代码实现

#include"Queue.h"
void QueueInit(Queue* pq)
{
	assert(pq);

	pq->head = pq->tail = NULL;
	pq->size = 0;
}
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)//当前指针为空，则结束循环
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
void QueuePush(Queue* pq, QDataType x)
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->head == NULL )
	{
		assert(pq->tail == NULL);
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	pq->size++;//重点
}
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head != NULL);
	/*
	QNode* next = ps->head->next;
	free(pq->head);
	pq->head = next;
	if(pq->head == NULL)
		pq->tail = NULL;
		//可读性差
	*/
	if (pq->head->next == NULL)
	{
		free(pq->head); 
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;
	
}
int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->size == 0;
}
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
	assert(pq);

	assert(!QueueEmpty(pq));
	return pq->tail->data;
}
void QueuePrint(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)//当前指针为空，则结束循环
	{
		printf("%c -> ", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

最后是最关键的层序代码实现和测试

#include"Queue.h"

typedef int BTDataType;
typedef struct BinaryTreeNode 
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

BTNode* BuyNode(BTDataType x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	node->data = x;
	node->left = NULL;
	node->right = NULL;
	return node;
}

BTNode* CreatTree()
{
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);
	BTNode* node7 = BuyNode(7);
	
	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;
	node3->right = node7;
	return node1;
}



void LevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePush(&q, root);

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		printf("%d", front->data);

		if (front->left)
			QueuePush(&q,front->left);
		if (front->right)
			QueuePush(&q,front->right);
	}
	QueueDestroy(&q);
}

int main()
{
	BTNode* root = CreatTree();
	LevelOrder(root);


	return 0;
}