二叉树的建立和遍历

#include <stdio.h>
#include <stdlib.h>
#define QUEUE_SIZE 5

//定义树的结构
typedef struct BTNode {
	char element;
	BTNode* left;
	BTNode* right;
}BTNode,*BTNodePtr;

//定义队列的结构
typedef struct BTNodePtrQueue {
	BTNodePtr* nodePtr;
	int front;
	int rear;
}BTNodePtrQueue,*QueuePtr;

//初始化队列
QueuePtr initQueue() {
	QueuePtr resultQueuePtr = new BTNodePtrQueue;
	resultQueuePtr->nodePtr = new BTNodePtr[QUEUE_SIZE];
	resultQueuePtr->front = 0;
	resultQueuePtr->rear = 1;
	return resultQueuePtr;
}

//判断队列是否为空
bool isqueueempty(QueuePtr paraQueuePtr) {
	if ((paraQueuePtr->front + 1) % QUEUE_SIZE == paraQueuePtr->rear) {
		return true;
	}
	return false;
}

//入队函数
void enqueue(QueuePtr paraQueuePtr, BTNodePtr paraBTNodePtr) {
	printf("front = %d, rear = %d.\r\n", paraQueuePtr->front, paraQueuePtr->rear);
	if ((paraQueuePtr->rear + 1) % QUEUE_SIZE == paraQueuePtr->front % QUEUE_SIZE) {
		printf("Error,trying to enqueue %c. queue is full.\r\n", paraBTNodePtr->element);
		return;
	}
	paraQueuePtr->nodePtr[paraQueuePtr->rear] = paraBTNodePtr;
	paraQueuePtr->rear = (paraQueuePtr->rear + 1) % QUEUE_SIZE;
	printf("enqueue %c ends.\r\n", paraBTNodePtr->element);
}

//出队函数
BTNodePtr dequeue(QueuePtr paraQueuePtr) {
	if (isqueueempty(paraQueuePtr)) {
		printf("Error,empty queue\r\n");
		return NULL;
	}

	paraQueuePtr->front = (paraQueuePtr->front + 1) % QUEUE_SIZE;
	printf("dequeue %c ends.\r\n", paraQueuePtr->nodePtr[paraQueuePtr->front]->element);
	return paraQueuePtr->nodePtr[paraQueuePtr->front];
}

//创建一个树节点
BTNodePtr constructBTNode(char paraChar) {
	BTNodePtr resultPtr = new BTNode;
	resultPtr->element = paraChar;
	resultPtr->left = NULL;
	resultPtr->right = NULL;
	return resultPtr;
}


//创建树
BTNodePtr stringToBTree(char* paraString) {
	int i;
	char ch;

	//用队列管理树的节点
	QueuePtr tempQueuePtr = initQueue();

	BTNodePtr resultHeader;
	BTNodePtr tempParent, tempLeftChild, tempRightChild;

	i = 0;
	ch = paraString[i];
	resultHeader = constructBTNode(ch);
	enqueue(tempQueuePtr, resultHeader);           //创建根节点

	while (!isqueueempty(tempQueuePtr))
	{
		tempParent = dequeue(tempQueuePtr);

		//The left child
		i++;
		ch = paraString[i];
		if (ch == '#') {
			tempParent->left = NULL;           //也可以不进行这步操作，因为创建节点时我们把left和right都设置为了NULL
		}
		else {
			tempLeftChild = constructBTNode(ch);
			enqueue(tempQueuePtr, tempLeftChild);
			tempParent->left = tempLeftChild;
		}

		//The right child
		i++;
		ch = paraString[i];
		if (ch == '#') {
			tempParent->right = NULL;         //同上，这一步也可以不进行
		}
		else {
			tempRightChild = constructBTNode(ch);
			enqueue(tempQueuePtr, tempRightChild);
			tempParent->right = tempRightChild;
		}
	}
	return resultHeader;
}


//层次化遍历
void levelwise(BTNodePtr paraTreePtr) {
	char tempString[100];
	int i = 0;
	QueuePtr tempQueuePtr = initQueue();
	BTNodePtr tempNodePtr;
	enqueue(tempQueuePtr, paraTreePtr);      //把根节点的指针存入队列
	while (!isqueueempty(tempQueuePtr)) {
		tempNodePtr = dequeue(tempQueuePtr); //取出指针

		tempString[i] = tempNodePtr->element; //用数组存放节点的元素
		i++;

		if (tempNodePtr->left != NULL) {
			enqueue(tempQueuePtr, tempNodePtr->left);  //如果left还有节点，则将节点的指针存入队列
		}
		if (tempNodePtr->right != NULL) {      
			enqueue(tempQueuePtr, tempNodePtr->right);   //如果right还有节点，则将节点的指针存入队列
		}
	}
	tempString[i] = '\0';
	printf("Levelwise: %s\r\n", tempString);    //输出element
}
  //Preorder.
void preorder(BTNodePtr tempPtr) {
	if (tempPtr == NULL) {
		return;
	}

	printf("%c", tempPtr->element);   //递归到哪个节点就先输出哪个节点的element
	preorder(tempPtr->left);
	preorder(tempPtr->right);
}


//Inorder.
void inorder(BTNodePtr tempPtr) {
	if (tempPtr == NULL) {
		return;
	}

	inorder(tempPtr->left);
	printf("%c", tempPtr->element);   //当前节点左指针调用完成后再输出当前节点的element
	inorder(tempPtr->right);
}


 //Post order.
void postorder(BTNodePtr tempPtr) {
	if (tempPtr == NULL) {
		return;
	}

	postorder(tempPtr->left);
	postorder(tempPtr->right);
	printf("%c", tempPtr->element);   //当前节点左右指针都调用完成后再输出当前节点的element
}


int main() {
	BTNodePtr tempHeader;
	tempHeader = constructBTNode('c');
	printf("There is only one node. Preorder visit: ");
	preorder(tempHeader);
	printf("\r\n");

	char* tempString =(char*) "acde#bf######";       //最后的#个数必须是最底层节点数的两倍，否则会一直循环

	tempHeader = stringToBTree(tempString);
	printf("Preorder: ");           
	preorder(tempHeader);           //前序遍历
	printf("\r\n");

	printf("Inorder: ");
	inorder(tempHeader);            //中序遍历
	printf("\r\n");

	printf("Postorder: ");
	postorder(tempHeader);          //后序遍历
	printf("\r\n");

	printf("Levelwise: ");
	levelwise(tempHeader);          //层次化遍历
	printf("\r\n");

	return 0;
}

 

 树的概念：

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。n=0的时候称为空树，把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

根结点：根节点没有前驱结点。
除根节点外，其余结点被分成是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。
因此，树是递归定义的。

子树与子树之间不能有交集，否则就不是树形结构。

二叉树的结构为：一个left指针，一个right指针，一个储存元素的element。在创建树的过程中我们运用了队列，把树节点的指针值存储在队列中，通过对指针值进行入队，出队的操作，实现树的创建。

二叉树的遍历有多种方法：前序，中序，后序其本质都是通过递归栈实现，三条语句都是相同的，唯一不同就在于输出函数的位置。前序print在第一个位置，所以在递归时每到一个节点都要先输出element，中序print在第二个位置，所以要等左指针调用完成后再输出当前节点的element，后序print在最后，所以要等当前节点左右指针都调用完成后再输出当前节点的element。

而层次化遍历也用到了队列来存储节点的指针值，在遍历的同时用数组来存储每个节点的element，最后遍历完成之后，再输出数组。