几道关于树的题目

1、将一棵有序二叉树，转换成一个有序的双向链表。
2、有一棵二叉树，生成它的镜像树，在原树上进行调整。
3、有两棵二叉树，A和B，判断B是否是A的子树。
4、现在有一个的前序遍历和中序编译，请重新构建出这棵二叉树。
{1,2,4,7,3,5,6,8}
{4,7,2,1,5,3,8,6}

5、判断一个序列是否是一棵二叉树的后序遍历结果。
bool is_post(int arr[],Node* root);
6、判断一棵二叉树是否是平衡二叉树。
首先是有序的二叉树，树的左右子树的高度相差不超过1，并且子树的子树都满足这个要求。

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "queue_list.h"

// 创建结点
TreeNode* creat_TreeNode(TYPE_T data);
// 修改
bool modify_tree(TreeNode* root,TYPE_T old,TYPE_T new);
// 访问
bool access_tree(TreeNode* root,size_t i,TYPE_T* p);
// 中序
void in_show(TreeNode* root);
// 添加
void add_tree(TreeNode** root,TYPE_T data);
// 删除
bool del_tree(TreeNode** root,TYPE_T data);

void level_show(TreeNode* root);

void add_list(TreeNode** head,TreeNode* node)//1、将一棵有序二叉树，转换成一个有序的双向链表。
{
	static TreeNode* tail = NULL;
	if(NULL == *head)//头添加 
	{   
		node->left = NULL;
		*head = node;
		tail = node;
		return;
	}     
	tail->right = node;//尾添加 tail的right指向node，node的left指向tail 双向链表互指
	node->left = tail;
	tail = node;
}

void tree_to_list(TreeNode* root,TreeNode** head)
{
	if(root == NULL) return;
	tree_to_list(root->left,head); 
	add_list(head,root);
	tree_to_list(root->right,head);
}

void tree_to_mirror(TreeNode* root)//2、有一棵二叉树，生成它的镜像树，在原树上进行调整。
{
	if(NULL == root) return;
	
	TreeNode* temp = root->left;
	root->left = root->right;
	root->right = temp;

	tree_to_mirror(root->left);
	tree_to_mirror(root->right);
}

void prev_show(TreeNode* root)//
{
	if(NULL == root) return;
	printf("%d ",root->data);
	prev_show(root->left);
	prev_show(root->right);
}

bool _is_sub_tree(TreeNode* a,TreeNode* b)//3、有两棵二叉树，A和B，判断B是否是A的子树。
{
	if(b == NULL) return true;
	if(a == NULL) return false;
	if(a->data != b->data) return false;
	return _is_sub_tree(a->left,b->left) && _is_sub_tree(a->right,b->right);
}

bool is_sub_tree(TreeNode* a,TreeNode* b)
{
	if(a == NULL) return false;
	bool flag1,flag2,flag3;
	if(a->data == b->data)
		flag1 = _is_sub_tree(a,b);//从根部开始相同
	flag2 = is_sub_tree(a->left,b);//b在a的左边
	flag3 = is_sub_tree(a->right,b);//b在a的右边
	return flag1 || flag2 || flag3;//三个中其中一个是true返回true
}

TreeNode* re_tree(TYPE_T* prev,TYPE_T* in,size_t size)//现在有一个的前序遍历和中序编译，请重新构建出这棵二叉树。
{
	if(size <= 0) return NULL;
	TreeNode* root = creat_TreeNode(prev[0]);
	int i=0;
	for(; i<size; i++)
	{
		if(prev[0] == in[i]) break;
	}

	root->left = re_tree(prev+1,in,i);
	root->right = re_tree(prev+i+1,in+i+1,size-i-1);
	return root;
}

bool _is_post(TreeNode* root,TYPE_T* post,size_t *ip)//判断一个序列是否是一棵二叉树的后序遍历结果。
{
	if(NULL == root) return true;
	
	bool flag1 = _is_post(root->left,post,ip);
	bool flag2 = _is_post(root->right,post,ip);
	bool flag3 = post[(*ip)++] == root->data;

	return flag1 && flag2 && flag3;
	
}

bool is_post(TreeNode* root,TYPE_T* post,size_t size)
{
	size_t i = 0;
	// 根据树的密码判断size的值是否过多
	return _is_post(root,post,&i);
}

size_t high_tree(TreeNode* root)
{
	if(NULL == root) return 0;
	size_t lh = high_tree(root->left);
	size_t rh = high_tree(root->right);
	return lh > rh ? lh+1 : rh+1;
}

bool is_balance(TreeNode* root)//判断一棵二叉树是否是平衡二叉树。
{
	if(NULL == root) return true;
	if(abs(high_tree(root->left)-high_tree(root->right))>1) return false;
	bool flag1 = is_balance(root->left);
	bool flag2 = is_balance(root->right);
	return flag1 && flag2;
}

int main()
{
	TYPE_T prev[] = {1,2,4};
	TYPE_T in[] = {2,1,4};
	TreeNode* tree = re_tree(prev,in,3); //= creat_TreeNode(50);
	printf("%s\n",is_balance(tree)?"yes":"no");
	printf("\n");
	/*for(int i=0; i<10; i++)
	{
		TYPE_T data = rand() % 100;
		printf("%d\n",data);
		add_tree(&tree,data);
	}
	TreeNode* tree2 = NULL;
	add_tree(&tree2,86);
	add_tree(&tree2,92);
	printf("%s\n",is_sub_tree(tree,tree2)?"是子树":"不是子树");

	in_show(tree),printf("\n");
	tree_to_mirror(tree);
	in_show(tree),printf("\n");
	prev_show(tree),printf("\n");
	*/
	/*reeNode* head = NULL;
	/tree_to_list(tree,&head);
	for(TreeNode* node = head; NULL != node; node=node->right)
	{
		printf("%d ",node->data);
	}
	printf("\n");*/
	
}

// 创建结点
TreeNode* creat_TreeNode(TYPE_T data)
{
	TreeNode* treeNode = malloc(sizeof(TreeNode));
	treeNode->data = data;
	treeNode->left = NULL;
	treeNode->right = NULL;
	return treeNode;
}

void _add_tree(TreeNode** root,TreeNode* TreeNode)
{
	if(NULL == *root)
	{
		*root = TreeNode;
		return;
	}
	
	if((*root)->data > TreeNode->data)
		_add_tree(&(*root)->left,TreeNode);
	else
		_add_tree(&(*root)->right,TreeNode);
}

// 添加
void add_tree(TreeNode** root,TYPE_T data)
{
	_add_tree(root,creat_TreeNode(data));	
}

// 删除
bool del_tree(TreeNode** root,TYPE_T data)
{
	if(NULL == *root) return false;
	if((*root)->data == data)
	{
		TreeNode* TreeNode = *root;
		*root = TreeNode->left;
		_add_tree(root,TreeNode->right);
		free(TreeNode);
		return true;
	}
	else if((*root)->data > data)
		return del_tree(&(*root)->left,data);
	else
		return del_tree(&(*root)->right,data);
}


// 修改
bool modify_tree(TreeNode* root,TYPE_T old,TYPE_T new);

// 访问
void _access_tree(TreeNode* root,size_t i,TYPE_T* p,size_t* indexp)
{
	if(NULL == root) return;
	_access_tree(root->left,i,p,indexp);
	if(i == *indexp)
	{
		*p = root->data;
		*indexp += 1;
		return;
	}
	*indexp += 1;
	_access_tree(root->right,i,p,indexp);
}

bool access_tree(TreeNode* root,size_t i,TYPE_T* p)
{
	size_t index = 0;
	_access_tree(root,i,p,&index);
	return true;
}

// 中序
void in_show(TreeNode* root)
{
	if(NULL == root) return;
	in_show(root->left);
	in_show(root->right);
	printf("%d,",root->data);
}



// 层序
void level_show(TreeNode* root)
{
	/*
	Queue* queue = creat_queue();
	push_queue(queue,root);
	
	while(!empty_queue(queue))
	{
		TreeNode* node = *head_queue(queue);
		printf("%d ",node->data);
		if(node->left) push_queue(queue,node->left);
		if(node->right) push_queue(queue,node->right);
		pop_queue(queue);
	}
	printf("\n");
	*/
}