二叉树的遍历与求深度的递归与非递归实现

//=========二叉树(Binary Tree)===========
#define _CRT_SECURE_NO_WARNINGS
#include<stack>
#include<queue>
using namespace std;
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define OVERFLOW -1
#define OK 1
#define ERROR 0
#define max(a , b) (a>b?a:b)//带参宏,听说比使用函数更好(inline)
#define TElemType int
#define Status int

//-----二叉树的链式存储---------------- 
typedef struct BiTNode {
	TElemType data;
	struct BiTNode *lChild, *rChild;
}BiTNode, *BiTree;

//----------基本操作的函数原型说明----------------- 
Status createBiTree(BiTree *T);
Status printBiTree(TElemType *data);
Status Add(TElemType *data);
Status PreorderTraverse(BiTree T, Status(*visit)(TElemType *data));
Status traversePreorder(BiTree T, Status(*visit)(TElemType *data));
Status InorderTraverse(BiTree T, Status(*visit)(TElemType* data));
Status PostorderTraverse(BiTree T, Status(*visit)(TElemType* data));
Status traversePostorder(BiTree T, Status(*visit)(TElemType* data));
Status traverseInorder(BiTree T, Status(*visit)(TElemType* data));
Status LevelOrderTraverse(BiTree T, Status(*visit)(TElemType* data));//层次遍历
int    BiTreeDepth(BiTree T);
int    depdhBiTree(BiTree T);
//Status clearBiTree(BiTree *T);//将树T清为空树
//Status destroyBiTree(BiTree *T);//摧毁二叉树T

//-----------------------------------------------------主函数----------------------------------------------------------------
int main() {
	//paste your code here
	//freopen("d:\\coding\\data.in", "r", stdin);
	BiTree T;
	createBiTree(&T);
	//PreorderTraverse(T, printBiTree);//已测试
	//InorderTraverse(T, printBiTree);//已测试
	//PostorderTraverse(T, printBiTree);//已测试
	//traverseInorder(T, printBiTree);//非递归中序遍历二叉树已测试
	//traversePreorder(T, printBiTree);//非递归先根序遍历二叉树，已测试
	//traversePostorder(T, printBiTree);//递推后根序遍历二叉树，已测试
	//LevelOrderTraverse(T, printBiTree);//层次遍历，已测试
	//printf("%d\n", BiTreeDepth(T));//求二叉树的深度，已测试
	//printf("%d\n",depdhBiTree(T));//递归求二叉树的深度，已测试
	InorderTraverse(T, printBiTree);
	printf("\n");
	traverseInorder(T,Add);
	InorderTraverse(T, printBiTree);

	while (1);
	return 0;
}

Status createBiTree(BiTree *T) {
	TElemType data;
	scanf("%d", &data);
	if (data == -1) (*T) = NULL;//每个叶子节点用-1表示，必须输入 
	else {
		if (!((*T) = (BiTree)malloc(sizeof(BiTNode)))) exit(OVERFLOW);
		(*T)->data = data;
		createBiTree(&((*T)->lChild));
		createBiTree(&((*T)->rChild));
	}

	return OK;
}
Status printBiTree(TElemType *data) {
	printf("%d\t", *data);
	return OK;
}
Status traversePreorder(BiTree T, Status(*visit)(TElemType *data)) {
	stack<BiTree>S;
	BiTree p = T;
	while (!(p == NULL && S.empty())) {
		if (p !=  NULL) {
			visit(&p->data);
			if (p->rChild != NULL) S.push(p->rChild);
			p = p->lChild;
		}
		else {
			p = S.top();
			S.pop();
		}
	}
	return OK;
}
Status traverseInorder(BiTree T, Status(*visit)(TElemType *data)) {
	stack<BiTree>S;
	BiTree p = T;//初始时指针p指向树根
	while (p != NULL || !S.empty()) {//递推结束条件
		while (p != NULL) {
			S.push(p);
			p = p->lChild;
		}		
		//此时p是空的，栈是不空的。因为若栈也空，则递推已经结束了，放心使用取值弹出操作
		p = S.top();
		S.pop();
		visit(&p->data);
		p = p->rChild;		
	}
	return OK;
}
Status traversePostorder(BiTree T, Status(*visit)(TElemType* data)) {
	stack<BiTree>S;
	BiTree p = T,pre=NULL;
	while (!(p == NULL && S.empty())) {
		if (p != NULL) {
			S.push(p);
			p = p->lChild;//直到左孩子为空，栈顶是最左下的节点
		}
		else {
			p = S.top();
			if (p->rChild != NULL && p->rChild!=pre) {//若果右子树存在且未被访问过
				p = p->rChild;
				S.push(p);
				p = p->lChild;
			}
			else {
				visit(&p->data);
				pre = p;
				S.pop();
				p = NULL;
			}
		}
	}//BINGO，设置了一个前驱指针，来区分右子树是否被访问过
	return OK;
}
Status PreorderTraverse(BiTree T, Status(*visit)(TElemType* data)) {
	//先序遍历
	if (T == NULL) return OK;//若二叉树为空，则空操作
	visit(&T->data);//访问根节点
	PreorderTraverse(T->lChild, visit);//先序遍历左子树
	PreorderTraverse(T->rChild, visit);//先序遍历右子树
	return OK;//返回值
}
Status InorderTraverse(BiTree T, Status(*visit)(TElemType* data)) {
	if (T == NULL)return OK;//二叉树为空，则空操作
	InorderTraverse(T->lChild, visit);//中序遍历左子树
	visit(&T->data);//访问根节点
	InorderTraverse(T->rChild, visit);//中序遍历右子树
	return OK;//返回值
}
Status PostorderTraverse(BiTree T, Status(*visit)(TElemType *data)) {
	//后序遍历
	if (T == NULL) return OK;//若二叉树为空，则空操作
	PostorderTraverse(T->lChild, visit);//中序遍历左子树
	PostorderTraverse(T->rChild, visit);//中序遍历右子树
	visit(&T->data);//访问根节点
	return OK;//返回值
}
Status LevelOrderTraverse(BiTree T, Status(*visit)(TElemType* data)) {
	//层次遍历二叉树，理论上用宽度优先搜索的思想可以实现此遍历
	queue<BiTree>Q;
	Q.push(T);
	BiTree p = NULL;
	while (!Q.empty()) {
		p = Q.front();
		visit(&p->data);
		Q.pop();
		if (p->lChild != NULL) {
			Q.push(p->lChild);
		}
		if (p->rChild != NULL) {
			Q.push(p->rChild);
		}
	}//一遍过
	return OK;
}
int    BiTreeDepth(BiTree T) {
	//用深度搜索的思想应该能实现，分递归、递推两种
	int length = 0;//初始化树的深度
	BiTree p = T;
	if (p == NULL) return 0;//递归出口，千万不要死循环了
	length = length + 1 + max(BiTreeDepth(p->lChild), BiTreeDepth(p->rChild));
	return length;//递归还是比较容易实现的
}
int    depdhBiTree(BiTree T) {
	if (T == NULL) return 0;
	int length = 1;//根算一层
	BiTree p = T;
	queue<BiTree>Q;
	Q.push(T);
	Q.push(NULL);//NULL表示一层结束
	while (Q.size()>1) {//有一个层结束标志时而在队列中
		p = Q.front();
		Q.pop();
		if (p != NULL) {
			if (p->lChild != NULL) Q.push(p->lChild);
			if (p->rChild != NULL) Q.push(p->rChild);
		}
		else {
			length++;
			Q.push(NULL);
		}
	}
	return length;
}
Status Add(TElemType *data) {
	(*data)++;
	return OK;
}

//宽度优先搜索BFS用队列；而且深度优先搜索也用队列
//若出现一个无法解析的……，说明函数名写错了
//优先级 ->第一级，*和&同级（自右至左）

/*输入数据：
1 2 8 -1 10 -1 -1 9 -1 -1 3 4 -1 -1 5 -1 6 -1 7 -1 -1
*/