数据结构之二叉树

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stddef.h>


typedef char TreeNodeType;

typedef struct TreeNode {
	TreeNodeType data;
	struct TreeNode* lchild;
	struct TreeNode* rchild;
} TreeNode;

void TreeInit(TreeNode** root);

void PreOrder(TreeNode* root);

void InOrder(TreeNode* root);

void PostOrder(TreeNode* root);

void LevelOrder(TreeNode* root);

/**
* @brief 根据先序遍历结果(带有空节点标记),
* 构造一棵树
*
* @param array[] 先序遍历的结果
* @param size 数组中元素个数
* @param null_node 数组中空节点的特殊标记.
*
* @return
*/
TreeNode* TreeCreate(TreeNodeType array[],
	size_t size, TreeNodeType null_node);

void TreeDestroy(TreeNode** root);

TreeNode* TreeClone(TreeNode* root);

size_t TreeSize(TreeNode* root);

/**
* @brief 求一棵树的叶子节点个数
*
* @param root
*
* @return
*/
size_t TreeLeafSize(TreeNode* root);

/**
* @brief 求一棵树第 K 层节点的个数
*
* @param root
*
* @return
*/
size_t TreeKLevelSize(TreeNode* root, int K);

size_t TreeHeight(TreeNode* root);

TreeNode* TreeFind(TreeNode* root, TreeNodeType to_find);

TreeNode* LChild(TreeNode* node);

TreeNode* RChild(TreeNode* node);

TreeNode* Parent(TreeNode* root, TreeNode* node);

void PreOrderByLoop(TreeNode* root);

void InOrderByLoop(TreeNode* root);

void PostOrderByLoop(TreeNode* root);

void TreeMirror(TreeNode* root);

int IsCompleteTree(TreeNode* root);

#define _CRT_SECURE_NO_WARNINGS 1
//#include"seqstack.h"
#include<Windows.h>
#include"bin_tree.h"
#include"stacklist.h"
//#if 1
//struct TreeNode;
//typedef struct TreeNode* SeqQueueType;
//#else
//typedef char LinkQuqueType;
//#endif

void TreeInit(TreeNode** root)
{
	if (root == NULL)
	{
		return;
	}
	*root = NULL;
}
void PreOrder(TreeNode* root)//先序遍历
{
	if (root == NULL)
	{
		return;
	}
	printf("%c", root->data);
	PreOrder(root->lchild);
	PreOrder(root->rchild);
}
TreeNode*GreateTreeNode(TreeNodeType value)
{
	TreeNode* new_node = (TreeNode*)malloc(sizeof(TreeNode));
	new_node->data = value;
	new_node->lchild = NULL;
	new_node->rchild = NULL;
	return new_node;
}
void InOrder(TreeNode* root)//中序遍历
{
	if (root == NULL)
	{
		return;
	}
	InOrder(root->lchild);
	printf("%c", root->data);
	InOrder(root->rchild);
}
void PostOrder(TreeNode* root)//后序遍历
{
	if (root == NULL)
	{
		return;
	}
	PostOrder(root->lchild);
	PostOrder(root->rchild);
	printf("%c", root->data);
}



//层序遍历，利用队列来实现
void LeveOrder(TreeNode* root)
{
	LinkQueueNode q;
	LinkQueueInit(&q);
	LinkQueuePush(&q,root->data);//先把根结点插入队列
	TreeNode* cur = NULL;
	while (LinkQueueFront(&q, &cur))//循环取队首元素
	{
		printf("%c", cur->data);
		LinkQueuePop(&q);//出队列
		if (cur->lchild != NULL)
		{
			LinkQueuePush(&q, cur->lchild);
		}
		if (cur->rchild != NULL)
		{
			LinkQueuePush(&q, cur->rchild);
		}
	}

}

TreeNode* _TreeGreate(TreeNodeType arr[], size_t size, size_t* index, TreeNodeType null_node)
{
	if (index == NULL)
	{
		return NULL;
	}
	if (*index >= size)
	{
		return NULL;
	}
	if (arr[*index] == null_node)
	{
		return NULL;
	}
	TreeNode* new_node = GreateTreeNode(arr[*index]);
	++(*index);
	new_node->lchild = _TreeGreate(arr, size, index, null_node);
	++(*index);
	new_node->rchild = _TreeGreate(arr, size, index, null_node);
	return new_node;
}
TreeNode* TreeGreate(TreeNodeType arr[], size_t size, TreeNodeType null_node)
{
	size_t index=0;//表示当前读到了第index个元素
	return _TreeGreate(arr, size, &index, null_node);
}
void DestroyTreeNode(TreeNode* ptr)
{
	free(ptr);
}
void TreeDelete(TreeNode** root)
{
	if (root == NULL)
	{
		return;
	}
	TreeNode* to_delete = *root;
	DestroyTreeNode(to_delete);
	TreeDelete(&to_delete->lchild);
	TreeDelete(&to_delete->rchild);
	*root = NULL;
}
TreeNode* TreeClone(TreeNode* root)
{
	if (root == NULL)
	{
		return  NULL;
	}
	TreeNode* new_node = GreateTreeNode(root->data);
	new_node->lchild = TreeClone(root->lchild);
	new_node->rchild = TreeClone(root->rchild);
	return new_node;
}

void _TreeSize(TreeNode* root, size_t* size)
{
	if (root == NULL||size==NULL)
	{
		return;
	}
	++(*size);
	_TreeSize(root->lchild, size);
	_TreeSize(root->rchild, size);
}
size_t TreeSize(TreeNode* root)
{
	size_t count = 0;
	_TreeSize(root, &count);
	return count;
}
size_t TreeLevelSize(TreeNode* root, int k)
{
	if (root == NULL || k < 1)
	{
		return 0;
	}
	if (k == 1)
	{
		return 1;
	}
	return TreeLevelSize(root->lchild, k - 1) + TreeLevelSize(root->rchild, k - 1);
}
//求出二叉树的高度
size_t TreeHeight(TreeNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	size_t lheight = TreeHeight(root->lchild);
	size_t rheight = TreeHeight(root->rchild);
	return lheight > rheight ? lheight + 1 : rheight + 1;
}
//查找树上某一结点的位置
TreeNode* TreeFind(TreeNode* root, TreeNodeType to_find)
{
	if (root == NULL )
	{
		return NULL;
	}
	if (root->data == to_find)
	{
		return root;
	}
	TreeNode*lfind=TreeFind(root->lchild, to_find);
	TreeNode*rfind=TreeFind(root->rchild, to_find);
	return lfind != NULL ? lfind : rfind;
}
//求某节点的左孩子
TreeNode* Lchild(TreeNode*node)
{
	if (node == NULL)
	{
		return NULL;
	}
	return node->lchild;
}
//求某节点的父节点
TreeNode*Parent(TreeNode*root, TreeNode* node)
{
	if (root == NULL || node == NULL)
	{
		return NULL;
	}
	TreeNode*cur = root;
	if (cur->lchild == node || cur->rchild == node)
	{
		return cur;
	}
	TreeNode*lresult = Parent(root->lchild, node);
	TreeNode*rresult = Parent(root->rchild, node);
	return lresult != NULL ? rresult : lresult;
}
//循环判断先序遍历
//void PreOrderByLoop(TreeNode* root)
//{
//	if (root == NULL)
//	{
//		return ;
//	}
//	SeqStack stack;
//	SeqStackInit(&stack);
//	SeqStackPush(&stack,root);
//	while (1)
//	{
//		TreeNode*top = NULL;
//		SeqStackTop(&stack, &top);
//		if (top == NULL)
//		{
//			break;
//		}
//		printf("%c", top->data);//访问当前栈顶元素
//		SeqStackPop(&stack);//将栈顶元素出栈
//		if (top->rchild != NULL)
//		{
//			SeqStackPush(top->rchild);
//		}
//		if (top->lchild != NULL)
//		{
//			SeqStackPush(top->lchild);
//		}
//	}
//}
循环判断中序遍历
//void InOrderByLoop(TreeNode* root)
//{
//	if (root == NULL)
//	{
//		return;
//	}
//	SeqStack stack;
//	SeqStackInit(&stack);
//	TreeNode* cur = root;
//	while (1)
//	{
//		TreeNode* top = NULL;
//		// 从根节点出发，找到当前最左侧的节点，每经过一个节点，就将它入栈
//		while (cur != NULL)
//		{
//			SeqStackPush(&stack, &top);
//			cur = cur->lchild;
//		}
//		//取栈顶元素，访问，并将元素出栈
//		SeqStackTop（&stack, &top);
//		if (top == NULL)
//		{
//			break;
//		}
//		printf("%c", top->data);
//		SeqStackPop（&stack);
//		//处理当前元素的右子树，回到循环开始，再去找右子树的最左侧节点
//		cur = top->rchild;
//	}
//	printf("\n");
//	return;
//	
//}
循环判断后序遍历
//void PostOrderByLoop(TreeNode* root)
//{
//	if (root == NULL)
//	{
//		return;
//	}
//	SeqStack stack;
//	SeqStackInit(&stack);
//	TreeNode* cur = root;
//	TreeNode* pre = root->rchild;
//	while (1)
//	{
//		TreeNode* top = NULL;
//		while (cur != NULL)
//		{
//			SeqStackPush(&stack, cur);
//			cur = cur->lchild;
//		}
//		SeqStackTop(&stack, &top);
//		if (top == NULL)
//		{
//			break;
//		}
//		//如果top的右子树为空或者已被访问
//		if (top->rchild == NULL||top->top->rchild==pre)
//		{
//			printf("%c", top->data);
//			SeqStackPop(&stack);
//			pre = top;
//		}
//		else
//		{
//			cur = cur->rchild;
//		}
//	}
//
//}
二叉树的镜像
//void TreeMirror(TreeNode* root)
//{
//	if (root == NULL)
//	{
//		return;
//	}
//	TreeNode* cur = root->lchild;
//	root->lchild = root->rchild;
//	root->rchild = cur;
//	TreeMirror(root->lchild);
//	TreeMirror(root->rchild);
//}
判断完全二叉树
//int IsCompleteTree(TreeNode* root)
//{
//	if (root == NULL)
//	{
//		return 1;//空树是完全二叉树
//	}
//	LinkQueueNode queue;
//	LinkQueueInit(&queue);
//	int flag = 1;
//	LinkQueuePush(&queue, root);
//	while (1)
//	{
//		TreeNode* cur = NULL;
//		LinkQueueFront(&queue, cur);
//		if (cur == NULL)
//		{
//			break;//遍历结束
//		}
//		if (flag == 0)
//		{
//			if (cur->lchild != NULL&&cur->rchild != NULL)
//			{
//				SeqQueuePush(&queue, cur->lchild);
//				SeqQueuePush(&queue, cur->rchild);
//			}
//			else if (cur->lchild == NULL&&cur->rchild != NULL)
//			{
//				return 0;
//			}
//			else if (cur->lchild != NULL&&cur->rchild == NULL)
//			{
//				flag=1;
//			}
//			else if (cur->lchild == NULL&&cur->rchild == NULL)
//			{
//				flag = 1;
//			}
//		}
//		else
//		{
//			if (cur->lchild == NULL&&cur->rchild == NULL)
//			{
//				continue;
//			}
//			else
//			{
//				return 0;
//			}
//		}
//		LinkQueuePop(&stack);
//	}	
//	return 1;
//}
二叉树还原
//TreeNode* _RebuildTree(TreeNodeType pre_order[], size_t pre_order_size, TreeNodeType in_order[],\
//	                   size_t* index,size_t in_order_left,  size_t in_order_right)
//{
//	if (in_order_left >= in_order_right)
//	{
//		return NULL;
//	}
//	if (*index >= pre_order_size)
//	{
//		return NULL;
//	}
//
//}
//TreeNode* RebuildTree(TreeNodeType pre_order[], size_t pre_order_size, TreeNodeType in_order[],\
//						int x, size_t in_order_size)
//{
//	size_t index = 0;
//	_RebuildTree(pre_order[], pre_order_size, in_order[], &index, 0, in_order_size);
//}
void test()
{
	TreeNode  *root;
	TreeNode  *root1;
	TreeInit(&root);
	TreeNodeType array[] = "abd##eg###c#f##";
	size_t size = sizeof(array) / sizeof(array[0]);
	size_t num = 0;
	root=TreeGreate(array, size, '#');
	//PostOrder(root);
	//root1=TreeClone(root);
	//TreeDelete(&root);
	//PostOrder(root1);
	num=TreeSize(root);
	printf("%lu\n", num);
	num=TreeLevelSize(root, 2);
	printf("%lu\n", num);
	num = TreeHeight(root);
	printf("%lu\n", num);
	root1 = TreeFind(root, 'a');
	printf("%c\n", root1->data);
}

int main()
{
	test();
	system("pause");
	return 0;
}