二叉树（递归遍历和非递归遍历）（递归求树的高度以及叶子节点数和拷贝树）

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include "LinkQueue.h"
#include "LinkStack.h"
/*
前序遍历：先中 再左 再右
中序遍历：先左 再中 再右
后序遍历：先左 再右 再中
*/
typedef struct _Tag_BiNode//节点结构体
{
	char ch;
	struct _Tag_BiNode *lchild;
	struct _Tag_BiNode *rchild;
}BiNode;
BiNode *CreateBiNode(char ch, BiNode *lchild,BiNode *rchild)//创建二叉树节点
{
	BiNode *p = (BiNode *)malloc(sizeof(BiNode));
	if (p == NULL)
	{
		return NULL;
	}
	p->ch = ch;
	p->lchild = lchild;
	p->rchild = rchild;
	return p;
}
BiNode *CreateTree()
{
	BiNode *node1 = CreateBiNode('A',NULL,NULL);
	BiNode *node2 = CreateBiNode('B',NULL,NULL);
	BiNode *node3 = CreateBiNode('C',NULL,NULL);
	BiNode *node4 = CreateBiNode('D',NULL,NULL);
	BiNode *node5 = CreateBiNode('E',NULL,NULL);
	BiNode *node6 = CreateBiNode('F',NULL,NULL);
	BiNode *node7 = CreateBiNode('G',NULL,NULL);
	BiNode *node8 = CreateBiNode('H',NULL,NULL);

	 node1->lchild = node2;
	 node1->rchild = node6;
	 node2->rchild = node3;
	 node3->lchild = node4;
	 node3->rchild = node5;
	 node6->rchild = node7;
	 node7->lchild = node8;//先序遍历   ABCDEFGH    中序遍历  BDCEAFHG     后序遍历  DECBHGFA
	 return node1;
}
void recursion(BiNode *root)//递归遍历
{
	if (root == NULL)
	{
		return;
	}
	//printf("%c", root->ch);//打印节点     前序遍历
	recursion(root->lchild);//递归打印左孩子
	//printf("%c", root->ch);//打印节点     中序遍历
	recursion(root->rchild);//递归打印右孩子
	printf("%c", root->ch);//打印节点     后序遍历
}

void CaculateLeavesNum(BiNode *root,int *num)//递归计算叶子节点数
{
	if (root == NULL)//如果节点为空 则返回
	{
		return ;
	}
	if (root->lchild == NULL && root->rchild == NULL)//如果当前节点左右节点都为空 则叶子节点数加一
	{
		(*num)++;
	}
	CaculateLeavesNum(root->lchild,num);//计算左孩子
	CaculateLeavesNum(root->rchild,num);//计算右孩子
}
int TreeHeight(BiNode *root)//递归计算树的高度
{
	if (root == NULL)//如果节点为空返回
	{
		return 0;
	}
	int LeftTreeHeight = TreeHeight(root->lchild);//计算左子树高度
	int RightTreeHeight = TreeHeight(root->rchild);//计算右子数高度
	return LeftTreeHeight > RightTreeHeight ? LeftTreeHeight + 1 : RightTreeHeight + 1;//返回左右子树中最高的
}

BiNode * CopyTree(BiNode * root)//拷贝树
{
	if (root == NULL)//如果节点为空，返回空
	{
		return NULL;
	}
	BiNode *lchild = CopyTree(root->lchild);//拷贝左子树   ， 接受返回的地址
	BiNode *rchild = CopyTree(root->rchild);//拷贝右子树   ， 接受返回的地址
	BiNode *newnode = (BiNode *)malloc(sizeof(BiNode));//建立一个新的节点
	newnode->ch = root->ch;//保存当前节点的数据
	newnode->lchild = lchild;//左子树
	newnode->rchild = rchild;//右子树
	return newnode;//返回新节点
}
void FreeBiNode(BiNode *root)
{
	if (root == NULL)
	{
		return;
	}
	//释放左子树
	FreeBiNode(root->lchild);
	//释放右子树
	FreeBiNode(root->rchild);
	//释放根节点
	free(root);
}
/* 
二叉树层序遍历：
1 先初始化队列，然后把根节点入队
2 while循环
{
 （1） 从队列中获取对头元素并输出
 （2）循环结束的标志是队列为空，如果左子树不为空，左子树入队列
  右子树不为空，右子树入队列
}
*/
void ForeachBinaryTree(BiNode * root)//层序遍历二叉树
{
	
	if (root == NULL)
	{
		return;
	}
	LQueue *queue = Init_LinkQueue();//初始化队列
	if (queue == NULL)
	{
		return;
	}
	Push_LinkQueue(queue, root);//根节点入队列
	while (GetSize_LinkQueue(queue) > 0)//如果队列不为空
	{
		BiNode *temp = (BiNode *)GetFront_LinkQueue(queue);//获取队头
		printf("%c", temp->ch);//打印队头
		Pop_LinkQueue(queue);//删除队头
		if (temp->lchild != NULL)//如果左节点不为空，左节点入队列
		{
			Push_LinkQueue(queue, temp->lchild);
		}
		if (temp->rchild != NULL)//如果右节点不为空，右节点入队列
		{
			Push_LinkQueue(queue, temp->rchild);
		}
	}
	printf("\n");
	Destroy_LinkQueue(queue);//销毁队列

}
/*
二叉树非递归遍历（前序遍历 ， 中序遍历 ，后序遍历）:
将树的节点存放在结构体内，结构体内包含一个标志位，任何节点第一次入栈时置为False,第二次入栈时置为True
步骤：
1 先初始化栈
2 根节点入栈 第一次入栈标志位为False
3 while 循环（如果栈不为空）
{
（1）获取栈顶元素，栈顶元素出栈
（2）如果获得栈顶元素为空，则跳过本次循环，如果获得的栈顶元素不为空的话，如果标志位为True，则输出
（3）如果获得的栈顶元素标志位为False,该节点的右孩子入栈（标志位为False），再左孩子入栈（标志位为False），根节点入栈（第二次入栈根节点为True）
     前序遍历（此时为逆序  先右 再左 再中） 中序遍历（右 中 左）  后序遍历（中 右 左）
}
*/
typedef struct _Tag_Info
{
	BiNode *root;
	bool flag;
}Info;
Info * CreateNode(BiNode *root, bool flag)
{
	if (root == NULL)
	{
		return NULL;
	}
	Info * newnode = (Info *)malloc(sizeof(Info));
	if (newnode == NULL)
	{
		return NULL;
	}
	newnode->root = root;
	newnode->flag = flag;
	return newnode;
}
void ForeachNoRecusion(BiNode * root)//非递归遍历
{
	if (root == NULL)
	{
		return;
	}
	LStack *stack = Init_LinkStack();//初始化栈
	if (stack == NULL)
	{
		return;
	}
	Push_LinkStack(stack,CreateNode(root,false));
	while (GetSize_LinkStack(stack) > 0)
	{
		Info * temp = (Info *)Top_LinkStack(stack);//获取栈顶元素
		if (temp == NULL)
		{
			return;
		}
		Pop_LinkStack(stack);//出栈
		if (temp->root == NULL)
		{
			continue;
		}
		if (temp->flag == true)//如果标志位为TRUE
		{
			printf("%c", temp->root->ch);
			free(temp);//第二次出栈的时候，就可以释放内存了
		}
		else//如果标志位为FALSE
		{
			Push_LinkStack(stack, CreateNode(temp->root, true));//此处的入栈顺序与（前序遍历 中序遍历 后序遍历相反）（例如： 前序遍历  入栈顺序为右 左 中）

			Push_LinkStack(stack,CreateNode(temp->root->rchild, false));

			Push_LinkStack(stack, CreateNode(temp->root->lchild, false));
		}
	}
	Destroy_LinkStack(stack);
}

void test()
{
	BiNode * root = NULL;
	root = CreateTree();//获取一棵树
	recursion(root);//递归遍历
	printf("\n");

	int num = 0;
	CaculateLeavesNum(root, &num);//计算叶子节点数
	printf("当前叶子节点数为：%d\n", num);

	int height = TreeHeight(root);//获取树的高度
	printf("当前树的高度为%d\n", height);

	BiNode *copy_tree = CopyTree(root);//拷贝树
	recursion(copy_tree);//遍历
	printf("\n");

	ForeachBinaryTree(root);//非递归层序遍历
	ForeachNoRecusion(root);
	printf("\n");
	FreeBiNode(root);//释放
	FreeBiNode(copy_tree);//释放
}

void main()
{
	test();
	system("pause");
}