数据结构学习之——树的遍历（完整版）

树的遍历

第一次在这里写文章，记录一下这关于树的遍历的学习。
二叉树的遍历是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。

前序、中序、后序遍历

树的遍历有几种常用的方式：

先序遍历：

先访问根节点，再访问左子树，最后访问右子树。
A->B->D->F->E->C->G->H->I

中序遍历：

先访问左子树，再访问右子树，最后访问根节点。
D->B->E->F->A->G->H->C->I

后序遍历：

先访问左子树，再访问根节点，最后访问右子树。
D->E->F->B->H->G->I->C->A

采用递归的方式遍历

树的创建和结构体的定义：

//结构体长度声明
#define LEN_TREE  sizeof(struct TreeNode)
//树结构体
typedef struct TreeNode *Bintree;
//typedef Bintree Position;
typedef struct TreeNode {
	char data;
	Bintree left;
	Bintree right;
}TreeNode;
void MakeTree(struct TreeNode* root);               //创建二叉树
//递归遍历
void PreOrderTraversal(struct TreeNode* root);      
void InOrderTraversal(struct TreeNode* root);
void PostOrderTraversal(struct TreeNode* root);

先序遍历的递归实现：

//先序遍历 递归 ->A->B->D->F->E->C->G->H->I
void PreOrderTraversal(struct TreeNode* root) {
	if (root) {
		printf("->%c", root->data);
		PreOrderTraversal(root->left);
		PreOrderTraversal(root->right);
	}
}

中序遍历的递归实现：

//中序遍历 递归
void InOrderTraversal(struct TreeNode* root) {
	if (root) {
		InOrderTraversal(root->left);
		printf("->%c", root->data);
		InOrderTraversal(root->right);
	}
}

后序遍历的递归实现：

//后序遍历 递归
void PostOrderTraversal(struct TreeNode* root) {
	if (root) {
		PostOrderTraversal(root->left);
		PostOrderTraversal(root->right);
		printf("->%c", root->data);
	}
}

采用堆栈和队列（非递归）的遍历

队列出入栈定义：

//堆栈出入栈
void push(TreeNode *tree);
struct TreeNode * pop(void);
//队列出入列
void append(struct TreeNode* tree);
struct TreeNode* delet(void);

struct stack *top; //堆栈的顶端
struct link *head; //队列头
struct link *tail; //队列尾

先序遍历的堆栈实现：

//堆栈先序
void PreStcakTraversal(struct TreeNode* root) {
	struct TreeNode *T;
	T = (struct TreeNode*)malloc(LEN_TREE);
	T = root;
	while (T != NULL || top->next != NULL) {
		while (T != NULL) {
			printf("->%c", T->data);
			push(T);
			if (T->left != NULL)
				T = T->left;
			else
				T = NULL;
		}
		if (top->next != NULL) {
			T = pop();
			if (T->right != NULL)
				T = T->right;
			else
				T = NULL;
		}
	}
}

中序遍历的堆栈实现：

//堆栈中序
void InStcakTraversal(struct TreeNode* root) {
	struct TreeNode *T;
	T = (struct TreeNode*)malloc(LEN_TREE);
	T = root;
	while (T != NULL || top->next != NULL) {
		while (T != NULL) {
			push(T);
			if (T->left != NULL)
				T = T->left;
			else
				T = NULL;
		}
		if (top->next != NULL) {
			T = pop();
			printf("->%c", T->data);
			if (T->right != NULL)
				T = T->right;
			else
				T = NULL;
		}
	}
}

后序遍历的堆栈实现：

//堆栈后序
void PostStcakTraversal(struct TreeNode* root) {
	struct TreeNode *T;
	T = (struct TreeNode*)malloc(LEN_TREE);
	T = root;
	int i = 1;
	while (T != NULL || top->next != NULL) {
		while (T != NULL) {
			//printf("->%c", T->data);
			ls[i] = T->data;
			i++;
			push(T);
			if (T->right != NULL)
				T = T->right;
			else
				T = NULL;
		}
		if (top->next != NULL) {
			T = pop();
			if (T->left != NULL)
				T = T->left;
			else
				T = NULL;
		}
	}
	for (i--; i >= 1; i--) {
		printf("->%c", ls[i]);
	}
}

层序遍历的队列实现：

//队列层序遍历

void LayerLinkTraversal(struct TreeNode* root) {
	struct TreeNode* tree;
	append(root);
	while (tail->next != head) {
		tree = delet();
		printf("->%c", tree->data);
		if (tree->left) {
			append(tree->left);
		}
		if (tree->right) {
			append(tree->right);
		}
	}
}

参考文档