一，二叉树的构建和遍历

1，创建节点和栈

typedef struct BTNode
{
	char element;
	BTNode* left;
	BTNode* right;
}BTNode, *BTNodePtr;//创建树的结点

typedef struct BTNodePtrQueue
{
	BTNodePtr* nodePtrs;
	int front;
	int rear;
}BTNodePtrQueue, *QueuePtr;//创建栈

2，初始化栈

QueuePtr initQueue()
{
	QueuePtr resultQueuePtr = (QueuePtr)malloc(sizeof(struct BTNodePtrQueue));
	resultQueuePtr->nodePtrs = (BTNodePtr*)malloc(QUEUE_SIZE * sizeof(BTNodePtr));
	resultQueuePtr->front = 0;
	resultQueuePtr->rear = 1;
	return resultQueuePtr;
}//对栈进行初始化

3，判断栈是否为空

bool isQueueEmpty(QueuePtr paraQueuePtr)
{
	if ((paraQueuePtr->front + 1) % QUEUE_SIZE == paraQueuePtr->rear) 
	{
		return true;
	}

	return false;
}//判断栈是否为空

4，入栈

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("无法入栈%c. 栈满.\r\n", paraBTNodePtr->element);
		return;
	}//判断栈是否已满
	paraQueuePtr->nodePtrs[paraQueuePtr->rear] = paraBTNodePtr;
	paraQueuePtr->rear = (paraQueuePtr->rear + 1) % QUEUE_SIZE;
	printf("入栈一个%c.\r\n", paraBTNodePtr->element);
}//入栈

5，出栈

BTNodePtr dequeue(QueuePtr paraQueuePtr)
{
	if (isQueueEmpty(paraQueuePtr)) 
	{
		printf("栈空\r\n");
		return NULL;
	}//栈空，由上面判断栈空函数返回值判断

	paraQueuePtr->front = (paraQueuePtr->front + 1) % QUEUE_SIZE;

	printf("出栈一个%c.\r\n", paraQueuePtr->nodePtrs[paraQueuePtr->front]->element);
	return paraQueuePtr->nodePtrs[paraQueuePtr->front];
}//出栈

6，对入栈结点初始化

BTNodePtr constructBTNode(char paraChar)
{
	BTNodePtr resultPtr = (BTNodePtr)malloc(sizeof(BTNode));
	resultPtr->element = paraChar;
	resultPtr->left = NULL;
	resultPtr->right = NULL;
	return resultPtr;
}//对入栈结点的初始化

7，将栈转化为二叉树(层序转化)

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)==0) 
	{
		tempParent = dequeue(tempQueuePtr);

		i ++;
		ch = paraString[i];
		if (ch != '#')
		{
			tempLeftChild = constructBTNode(ch);
			enqueue(tempQueuePtr, tempLeftChild);
			tempParent->left = tempLeftChild;
		}
		i ++;
		ch = paraString[i];
		if (ch != '#') 
		{
			tempRightChild = constructBTNode(ch);
			enqueue(tempQueuePtr, tempRightChild);
			tempParent->right = tempRightChild;
		}
	}
	return resultHeader;
}//将栈转化为二叉树(层次转化)

8，层序遍历

void levelwise(BTNodePtr paraTreePtr)
{
	char tempString[100];
	int i = 0;
	QueuePtr tempQueuePtr = initQueue();
	BTNodePtr tempNodePtr;
	enqueue(tempQueuePtr, paraTreePtr);
	while(isQueueEmpty(tempQueuePtr)==0) 
	{
		tempNodePtr = dequeue(tempQueuePtr);
		
		tempString[i] = tempNodePtr->element;
		i ++;

		if (tempNodePtr->left != NULL)
		{
			enqueue(tempQueuePtr, tempNodePtr->left);
		}
		if (tempNodePtr->right != NULL)
		{
			enqueue(tempQueuePtr, tempNodePtr->right);
		}
	}
	tempString[i] = '\0';
	
	printf("levelwise: %s\r\n",tempString);
}//层序遍历

9，各种遍历法

void preorder(BTNodePtr tempPtr)
{
	if (tempPtr == NULL)
	{
		return;
	}

	printf("%c", tempPtr->element);
	preorder(tempPtr->left);
	preorder(tempPtr->right);
}//中左右
void inorder(BTNodePtr tempPtr)
{
	if (tempPtr == NULL) 
	{
		return;
	}

	inorder(tempPtr->left);
	printf("%c", tempPtr->element);
	inorder(tempPtr->right);
}//左中右
void postorder(BTNodePtr tempPtr)
{
	if (tempPtr == NULL) 
	{
		return;
	}

	postorder(tempPtr->left);
	postorder(tempPtr->right);
	printf("%c", tempPtr->element);
}//左右中
void reorder(BTNodePtr tempPtr)
{
	if (tempPtr == NULL) 
	{
		return;
	}
	
	printf("%c",tempPtr->element);
	reorder(tempPtr->right);
	reorder(tempPtr->left);
}//中右左

10，全部代码以及运行结果

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

#define QUEUE_SIZE 5

typedef struct BTNode
{
	char element;
	BTNode* left;
	BTNode* right;
}BTNode, *BTNodePtr;//创建树的结点

typedef struct BTNodePtrQueue
{
	BTNodePtr* nodePtrs;
	int front;
	int rear;
}BTNodePtrQueue, *QueuePtr;//创建栈

QueuePtr initQueue()
{
	QueuePtr resultQueuePtr = (QueuePtr)malloc(sizeof(struct BTNodePtrQueue));
	resultQueuePtr->nodePtrs = (BTNodePtr*)malloc(QUEUE_SIZE * sizeof(BTNodePtr));
	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("无法入栈%c. 栈满.\r\n", paraBTNodePtr->element);
		return;
	}//判断栈是否已满
	paraQueuePtr->nodePtrs[paraQueuePtr->rear] = paraBTNodePtr;
	paraQueuePtr->rear = (paraQueuePtr->rear + 1) % QUEUE_SIZE;
	printf("入栈一个%c.\r\n", paraBTNodePtr->element);
}//入栈

BTNodePtr dequeue(QueuePtr paraQueuePtr)
{
	if (isQueueEmpty(paraQueuePtr)) 
	{
		printf("栈空\r\n");
		return NULL;
	}//栈空，由上面判断栈空函数返回值判断

	paraQueuePtr->front = (paraQueuePtr->front + 1) % QUEUE_SIZE;

	printf("出栈一个%c.\r\n", paraQueuePtr->nodePtrs[paraQueuePtr->front]->element);
	return paraQueuePtr->nodePtrs[paraQueuePtr->front];
}//出栈

BTNodePtr constructBTNode(char paraChar)
{
	BTNodePtr resultPtr = (BTNodePtr)malloc(sizeof(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)==0) 
	{
		tempParent = dequeue(tempQueuePtr);

		i ++;
		ch = paraString[i];
		if (ch != '#')
		{
			tempLeftChild = constructBTNode(ch);
			enqueue(tempQueuePtr, tempLeftChild);
			tempParent->left = tempLeftChild;
		}
		i ++;
		ch = paraString[i];
		if (ch != '#') 
		{
			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)==0) 
	{
		tempNodePtr = dequeue(tempQueuePtr);
		
		tempString[i] = tempNodePtr->element;
		i ++;

		if (tempNodePtr->left != NULL)
		{
			enqueue(tempQueuePtr, tempNodePtr->left);
		}
		if (tempNodePtr->right != NULL)
		{
			enqueue(tempQueuePtr, tempNodePtr->right);
		}
	}
	tempString[i] = '\0';
	
	printf("levelwise: %s\r\n",tempString);
}//层序遍历
void preorder(BTNodePtr tempPtr)
{
	if (tempPtr == NULL)
	{
		return;
	}

	printf("%c", tempPtr->element);
	preorder(tempPtr->left);
	preorder(tempPtr->right);
}//中左右
void inorder(BTNodePtr tempPtr)
{
	if (tempPtr == NULL) 
	{
		return;
	}

	inorder(tempPtr->left);
	printf("%c", tempPtr->element);
	inorder(tempPtr->right);
}//左中右
void postorder(BTNodePtr tempPtr)
{
	if (tempPtr == NULL) 
	{
		return;
	}

	postorder(tempPtr->left);
	postorder(tempPtr->right);
	printf("%c", tempPtr->element);
}//左右中
void reorder(BTNodePtr tempPtr)
{
	if (tempPtr == NULL) 
	{
		return;
	}
	
	printf("%c",tempPtr->element);
	reorder(tempPtr->right);
	reorder(tempPtr->left);
}//中右左
int main(){
	BTNodePtr tempHeader;
	printf("请输入一个二叉树，'#'代表此处没有分支\r\n");
	char* tempString;
	gets(tempString);

	tempHeader = stringToBTree(tempString);
	printf("Preorder: ");
	preorder(tempHeader);
	printf("\r\n");
	printf("Inorder: ");
	inorder(tempHeader);
	printf("\r\n");
	printf("reorder: ");
	reorder(tempHeader);
	printf("\r\n");
	printf("Postorder: ");
	postorder(tempHeader);
	printf("\r\n");
	printf("Levelwise: ");
	levelwise(tempHeader);
	printf("\r\n");
	
	return 0;
}