从递归（代码）的角度理解二叉树的先序/中序/后序三种遍历顺序

二叉树的遍历原理其实是很简单的，就是从二叉树的根节点开始，把它的左节点以及左节点下面的节点再当作一棵二叉树，和右节点以及右节点下面的节点也再当作一棵二叉树，依此类推，直到节点下面没有节点为止。

二叉树的有三种遍历顺序：先序遍历、中序遍历、后序遍历，而这个顺序都是以根节点作为参照的，最先遍历根节点就是先序遍历，最后遍历根节点就是后序遍历，根节点放在左右节点之间的情况就是中序遍历。

先看代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct treenode {
	void *data;
	struct treenode *left;
	struct treenode *right;
} treenode;

typedef struct tree {
	treenode *root;  //根节点
	//其他属性...
} tree;

treenode *make_node(void *data){
	treenode *node = malloc(sizeof(treenode));
	bzero(node, sizeof(*node));
	node->data = data;
	node->left = NULL;
	node->right = NULL;
	return node;
}

// 先序遍历 根节点 -> 左节点 -> 右节点
void first_sort_var_dump(const treenode *node) {
	if (node == NULL) {
		return;
	}
	printf("node->data: %s\n", (const char *)node->data);

	first_sort_var_dump(node->left);
	first_sort_var_dump(node->right);
}

// 中序遍历 左节点 -> 根节点 -> 右节点
void middle_sort_var_dump(const treenode *node) {
	if (node == NULL) {
		return;
	}
	middle_sort_var_dump(node->left);

	printf("node->data:%s\n", (const char *)node->data);

	middle_sort_var_dump(node->right);
}

// 后序遍历 左节点 -> 右节点 -> 根节点
void last_sort_var_dump(const treenode *node) {
	if (node == NULL) {
		return;
	}
	last_sort_var_dump(node->left);
	last_sort_var_dump(node->right);

	printf("node->data:%s\n", (const char *)node->data);
}

int main(){

	tree *t = malloc(sizeof(tree));
	bzero(t, sizeof(*t));

	treenode *root = make_node("I am root...");
	treenode *node1 = make_node("I am node1...");
	treenode *node2 = make_node("I am node2...");
	treenode *node3 = make_node("I am node3...");
	treenode *node4 = make_node("I am node4...");
	treenode *node5 = make_node("I am node5...");
	treenode *node6 = make_node("I am node6...");
	treenode *node7 = make_node("I am node7...");
	treenode *node8 = make_node("I am node8...");
	treenode *node9 = make_node("I am node9...");
	treenode *node10 = make_node("I am node10...");
	treenode *node11 = make_node("I am node11...");

	t->root = root;

	root->left = node1;
	root->right = node2;

	node1->left = node3;
	node1->right = node4;

	node3->left = node5;
	node3->right = node6;

	node5->left = node8;
	node8->right = node9;

	node2->left = node10;
	node2->right = node7;

	node7->left = node11;

	printf("先序遍历....\n");
	first_sort_var_dump(t->root);

	printf("\n中序遍历...\n");
	middle_sort_var_dump(t->root);

	printf("\n后序遍历...\n");
	last_sort_var_dump(t->root);

	return 0;
}

以上代码构造了一颗如下关系所示的二叉树：

从代码中可以非常直观的看到三种遍历顺序之间的不同，先序遍历是先获取根节点的值然后对左右节点进行递归，中序遍历是先递归左节点，然后获取根节点的值，最后递归右节点，后序遍历原理相同，然后结合递归的压栈和弹栈顺序，就可以分析出遍历的顺序了，所以说三种遍历顺序就是不同的递归调用顺序的表现。

所以表现出以下的打印结果：

先序遍历....
node->data: I am root...
node->data: I am node1...
node->data: I am node3...
node->data: I am node5...
node->data: I am node8...
node->data: I am node9...
node->data: I am node6...
node->data: I am node4...
node->data: I am node2...
node->data: I am node10...
node->data: I am node7...
node->data: I am node11...

中序遍历...
node->data:I am node8...
node->data:I am node9...
node->data:I am node5...
node->data:I am node3...
node->data:I am node6...
node->data:I am node1...
node->data:I am node4...
node->data:I am root...
node->data:I am node10...
node->data:I am node2...
node->data:I am node11...
node->data:I am node7...

后序遍历...
node->data:I am node9...
node->data:I am node8...
node->data:I am node5...
node->data:I am node6...
node->data:I am node3...
node->data:I am node4...
node->data:I am node1...
node->data:I am node10...
node->data:I am node11...
node->data:I am node7...
node->data:I am node2...
node->data:I am root...

先序比较相对好理解，这里以后序为例介绍一下递归调用栈的顺序

1、对 node1 和 node2 的递归分别称作 func1 和 func2，func1 执行完再执行func2，最后打印root节点的值，栈示意图如下：