C实现二叉树（模块化集成，遍历的递归与非递归实现）

C实现二叉树模块化集成

实验源码介绍（源代码的总体介绍）：

header.h : 头文件链栈，循环队列，二叉树的结构声明和相关函数的声明。

LinkStack.c : 链栈的相关操作函数定义。

Queue.c : 循环队列的相关操作函数定义。

BinTree.c : 二叉树的相关操作的函数定义，层序序列生成二叉树，二叉树的前序序列、中序序列、后序序列的递归和非递归实现，求叶子结点的递归与非递归实现，求树高。

我目前还是新手且第一次写类似的博客，文章中难免会有错误！如发现错误，望各路大神能够指出！

详见源代码！

源代码：header.h

/**
 * BinTree
 */
typedef int BinTree_Type;
typedef struct TreeNode BinTree;
struct TreeNode {
	BinTree_Type Data;
	BinTree *Left;
	BinTree *Right;
};

/**
 * Queue
 */
#define MaxSize 50
typedef BinTree * Q_ElementType;
typedef struct {
	Q_ElementType Data[MaxSize];
	int front;
	int rear;
} Queue;

extern Queue * InitQueue();
extern void Destory(Queue * q);
extern int IsQueueEmpty(Queue *q);
extern void EnQueue(Queue *q, Q_ElementType e);
extern Q_ElementType DeQueue(Queue* q);


/**
 * LinkStack
 */
typedef BinTree * L_ElementType;
typedef struct Node {
	L_ElementType Data;
	struct Node *next;
} LinkStack;

extern LinkStack * InitStack();
extern int IsStackEmpty(LinkStack *s);
extern void Push(LinkStack *s, L_ElementType e);
extern L_ElementType Pop(LinkStack *s);
extern L_ElementType getTop(LinkStack *s);

 

源代码：LinkStack.c

#include <stdio.h> //standard input output 标准输入输出头文件
#include <malloc.h> //memory allocation分配
#include "header.h"


/**
 * 初始化一个头结点为空的Stack
 * init a stack with a NULL head
 */
LinkStack * InitStack() {
	LinkStack *s = (LinkStack *) malloc(sizeof(LinkStack));
	s->next = NULL;
	return s;
}

/**
 * 若stack为空返回1,否则返回0
 */
int IsStackEmpty(LinkStack *s) {
	return s->next == NULL;
}

/**
 * 入栈
 */
void Push(LinkStack *s, L_ElementType e) {
	struct Node *p;
	p = (LinkStack *) malloc(sizeof(LinkStack));
	p->Data = e;
	p->next = s->next;
	s->next = p;
}

/**
 * 出栈
 */
L_ElementType Pop(LinkStack *s) {
	if (s->next == NULL) {
		printf("Stack is NULL");
		return NULL;
	}
	L_ElementType TopElem;
	struct Node *top;
	top = s->next;
	s->next = top->next;
	TopElem = top->Data;
	free(top);
	return TopElem;
}

/**
 * 返回栈顶元素
 */
L_ElementType getTop(LinkStack *s) {
	if (s->next == NULL) {
		printf("Stack is NULL");
		return NULL;
	}
	return s->next->Data;
}

 

源代码：Queue.c

#include <stdio.h>
#include <malloc.h>
#include "header.h"

/**
 * 初始化循环队列
 */
Queue * InitQueue() {
	Queue *q = (Queue *) malloc(sizeof(Queue));
	q->front = q->rear = 0;
	return q;
}

/**
 * 销毁队列
 */
void Destory(Queue * q) {
	free(q);
}

/**
 * 判断队列是否为空
 */
int IsQueueEmpty(Queue *q) {
	return q->front == q->rear;
}

/**
 * 入队
 */
void EnQueue(Queue *q, Q_ElementType e) {
	if ((q->rear + 1) % MaxSize == q->front) {
		printf("队列满了");
		return;
	}
	q->rear = (q->rear + 1) % MaxSize;
	q->Data[q->rear] = e;
}

/**
 * 出队
 */
Q_ElementType DeQueue(Queue* q) {
	if (q->front == q->rear) {
		printf("队列空了！");
		return NULL;
	}
	q->front = (q->front + 1) % MaxSize;
	return q->Data[q->front];
}

 

源代码：BinTree.c

#include <stdio.h>
#include <malloc.h>
#include "header.h"

/**
 * 访问
 */
void Visited(BinTree *BT) {
	printf("%d ", BT->Data);
}

/**
 * 层序生成二叉树
 */
BinTree *CreateBinTree() {
	BinTree_Type Data;
	BinTree *BT = NULL, *T = NULL;
	Queue * Q = NULL;
	Q = InitQueue(); 		/* 生成一个队列 */
	scanf("%d", &Data); 		/* 建立第一个结点,即根节点 */
	if (Data) { 		/* 分配结点单元,并将结点地址入队 */
		BT = (BinTree *) malloc(sizeof(BinTree));
		BT->Data = Data;
		EnQueue(Q, BT);
	} else {
		return NULL;		/* 若第一个数据就是0,则返回空树 */
	}
	while (!IsQueueEmpty(Q)) {
		T = DeQueue(Q); 		/* 从队列中取出一结点地址 */
		scanf("%d", &Data); 		/* 读入T的左孩子 */
		if (Data) { 		/* 分配新结点,作为出对结点左孩子 */
			T->Left = (BinTree *) malloc(sizeof(BinTree));
			T->Left->Data = Data;
			EnQueue(Q, T->Left); 		/* 新结点入队 */
		} else {
			T->Left = NULL;
		}
		scanf("%d", &Data); 		/* 读入T的右孩子 */
		if (Data) { 		/* 分配新结点,作为出对结点右孩子 */
			T->Right = (BinTree *) malloc(sizeof(BinTree));
			T->Right->Data = Data;
			EnQueue(Q, T->Right); 			/* 新结点入队 */
		} else {
			T->Right = NULL;
		}
	} 		/* 结束while */
	return BT;
}

/**
 * 遍历二叉树 递归算法
 */
void PreOrderTraversal(BinTree *BT) {
	if (BT) { 		//BT != NULL
		Visited(BT);
		PreOrderTraversal(BT->Left);
		PreOrderTraversal(BT->Right);
	}
}

void InOrderTraversal(BinTree *BT) {
	if (BT) {
		InOrderTraversal(BT->Left);
		Visited(BT);
		InOrderTraversal(BT->Right);
	}
}

void PostOrderTraversal(BinTree *BT) {
	if (BT) {
		PostOrderTraversal(BT->Left);
		PostOrderTraversal(BT->Right);
		Visited(BT);
	}
}

/**
 * 遍历二叉树 非递归算法
 */
/**
 * 前序遍历非递归算法
 */
void PreOrderTraversal_Iter(BinTree *BT) {
	BinTree *T;
	LinkStack * S = InitStack(); 		/* 生成一个堆栈 */
	T = BT;
	while (T || !IsStackEmpty(S)) {
		while (T) { 		/* 一直向左并访问沿途结点后压入堆栈S */
			Visited(T);
			Push(S, T);
			T = T->Left;
		}
		if (!IsStackEmpty(S)) {
			T = Pop(S); 		/* 结点弹出堆栈 */
			T = T->Right; 		/* 转向右子树 */
		}
	}
}

/**
 * 中序遍历非递归算法
 */
void InOrderTraversal_Iter(BinTree *BT) {
	BinTree *T;
	LinkStack * S = InitStack(); 		/* 生成一个堆栈 */
	T = BT;
	while (T || !IsStackEmpty(S)) {
		while (T) { 		/* 一直向左并将沿途结点后压入堆栈S */
			Push(S, T);
			T = T->Left;
		}
		if (!IsStackEmpty(S)) {
			T = Pop(S); 		/* 结点弹出堆栈 */
			Visited(T);
			T = T->Right; 		/* 转向右子树 */
		}
	}
}

/**
 * 后序遍历非递归算法一
 * 此思路来源于数据结构教程(李春葆主编)
 */
void PostOrderTraversal_Iter1(BinTree *BT) {
	if (BT == NULL)
		return;
	BinTree *p, *T;
	LinkStack * S = InitStack();
	T = BT;
	int flag = 0;
	do {
		while (T) { /*  一直向左并将沿途结点后压入堆栈S */
			Push(S, T);
			T = T->Left;
		}
		/* 执行到此处,栈顶元素没有做孩子或左子树均已访问过 */
		flag = 1; 			/* 表示 T的左孩子已访问或为空 */
		p = NULL; 			/* p指向栈顶结点的前一个已访问的结点  */
		while (!IsStackEmpty(S) && flag) {
			T = getTop(S); 			/* 获取当前的栈顶元素,不是删除 */
			/**
			 * 若p=NULL,表示T的右孩子不存在,而左孩子不存在或已经被访问过,所以访问T;
			 * 若p≠NULL,表示T的右孩子已访问(原因是p指向T的右子树中刚访问过的结点,而p是T的右孩子,
			 * 	p一定是T的右子树中后序序列的最后一个结点),所以可以访问T.
			 */
			if (p == T->Right) {
				Visited(T); 		/* 访问  */
				p = Pop(S); 		/* 弹出刚访问的结点并将p指向刚访问的结点 */
			} else {
				T = T->Right; 		/* T指向T的右孩子  */
				flag = 0; 		/* 表示T的右孩子尚未被访问过 */
			}
		}
	} while (!IsStackEmpty(S));

}

/**
 * 后序遍历非递归算法二
 *	思路：要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点p，先将其入栈。
 *	如果p不存在左孩子和右孩子，则可以直接访问它；
 *	或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。
 *	若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，
 *	左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。
 *	(此思路来源于博客园海子!!!)
 */
void PostOrderTraversal_Iter2(BinTree *BT) {
	if (!BT)
		return;
	BinTree *p, *cur;
	LinkStack *S = InitStack();
	p = NULL;
	cur = NULL;
	Push(S, BT);
	while (!IsStackEmpty(S)) {
		cur = getTop(S);
		if ((!cur->Left && !cur->Right) /* NULL==cur->Left && NULL==cur->Right */
		|| (p && (p == cur->Left || p == cur->Right))) {
			Visited(cur);
			p = Pop(S);
		} else {
			if (cur->Right) {
				Push(S, cur->Right);
			}
			if (cur->Left) {
				Push(S, cur->Left);
			}
		}
	}
}

/**
 * 层序遍历
 */
void LevelOrderTraversal(BinTree *BT) {
	BinTree *T;
	T = BT;
	if (!T) {
		return;
	}
	Queue *Q = InitQueue(); 	/* 生成一个队列 */
	EnQueue(Q, T); 		/* 根节点入队 */
	while (!IsQueueEmpty(Q)) { 		/* 队列不为空,弹出一个元素 */
		T = DeQueue(Q);
		Visited(T); 		/* 访问 */
		if (T->Left) 		/* 左子树不为空入队 */
			EnQueue(Q, T->Left);
		if (T->Right)	 /* 右子树不为空入队 */
			EnQueue(Q, T->Right);
	}
}

/**
 * 访问叶子结点的递归算法
 */
void getOrderPrintLeaves(BinTree *BT) {
	if (BT) {
		if (!BT->Left && !BT->Right) {
			Visited(BT);
		}
		getOrderPrintLeaves(BT->Left);
		getOrderPrintLeaves(BT->Right);
	}
}

/**
 * 访问叶子结点的非递归算法
 */
void getOrderPrintLeaves_Iter(BinTree *BT) {
	BinTree *T;
	LinkStack *S = InitStack();
	T = BT;
	while (T || !IsStackEmpty(S)) {
		while (T) {
			Push(S, T);
			T = T->Left;
		}
		if (!IsStackEmpty(S)) {
			T = Pop(S);
			if (!T->Left && !T->Right) { /* 当该结点的左子树和右子树都为空,访问 */
				Visited(T);
			}
			T = T->Right;
		}
	}
}

/**
 * 求树高
 */
int PostOrderGetHeight(BinTree *BT) {
	int LH, RH, MaxH;
	if (BT) {
		LH = PostOrderGetHeight(BT->Left);
		RH = PostOrderGetHeight(BT->Right);
		MaxH = (LH > RH ? LH : RH);
		return MaxH + 1;
	}
	return 0;
}

 

源代码：Test.c

#include <stdio.h>
#include <stdlib.h>
#include "header.h"

extern BinTree *CreateBinTree();
extern void PreOrderTraversal(BinTree *BT);
extern void InOrderTraversal(BinTree *BT);
extern void PreOrderTraversal(BinTree *BT);
extern void InOrderTraversal(BinTree *BT);
extern void PostOrderTraversal(BinTree *BT);
extern void PreOrderTraversal_Iter(BinTree *BT);
extern void InOrderTraversal_Iter(BinTree *BT);
extern void PostOrderTraversal_Iter1(BinTree *BT);
extern void PostOrderTraversal_Iter2(BinTree *BT);
extern void LevelOrderTraversal(BinTree *BT);
extern void getOrderPrintLeaves(BinTree *BT);
extern void getOrderPrintLeaves_Iter(BinTree *BT);
extern int PostOrderGetHeight(BinTree *BT);

int main() {
	puts("START!!!");

	printf("\n层序序列生成二叉树，请输入层序序列(类型为int,0代表为树的位置为NULL)：\n");
	BinTree * BT = CreateBinTree();

	printf("PreOrderTraversal: ");
	PreOrderTraversal(BT);
	printf("\n");

	printf("InOrderTraversal: ");
	InOrderTraversal(BT);
	printf("\n");

	printf("PostOrderTraversal: ");
	PostOrderTraversal(BT);
	printf("\n");

	printf("PreOrderTraversal_Iter: ");
	PreOrderTraversal_Iter(BT);
	printf("\n");

	printf("InOrderTraversal_Iter: ");
	InOrderTraversal_Iter(BT);
	printf("\n");

	printf("PostOrderTraversal_Iter1: ");
	PostOrderTraversal_Iter1(BT);
	printf("\n");

	printf("PostOrderTraversal_Iter2:");
	PostOrderTraversal_Iter2(BT);
	printf("\n");

	printf("LevelOrderTraversal: ");
	LevelOrderTraversal(BT);
	printf("\n");

	printf("getOrderPrintLeaves: ");
	getOrderPrintLeaves(BT);
	printf("\n");

	printf("getOrderPrintLeaves_Iter: ");
	getOrderPrintLeaves_Iter(BT);
	printf("\n");

	printf("PostOrderGetHeight: %d",PostOrderGetHeight(BT));
	printf("\n");

	puts("END!!!");
	return EXIT_SUCCESS;
}

运行结果：