【数据结构与算法】链式结构的二叉树，通过前序和中序来创建树

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "queue.h"
//构造树结点
typedef struct TreeNode
{
	char data;
	struct TreeNode* left;
	struct TreeNode* right;
}TreeNode;
//创建结点
TreeNode* create_tree_node(char data)
{
	TreeNode* tree = malloc(sizeof(TreeNode));
	tree->data = data;
	tree->left = NULL;
	tree->right = NULL;
	return tree;
}
/*//用字符串来传前序
const char* str;
//创建树
TreeNode* create_tree_dlr()
{
	if('#' == *str)
		return NULL;
	TreeNode* tree = create_tree_node(*str);
	tree->left = create_tree_dlr(++str);
	tree->right = create_tree_dlr(++str);
	return tree;
}*/
//根据前序和中序来创建树
TreeNode* create_tree(char* a,char* b,size_t size)
{
	if(0 == size)
		return NULL;

	int i;
	for(i=0; i<size && b[i]!=*a; i++);
	TreeNode* tree = create_tree_node(*a);
	tree->left = create_tree(a+1,b,i);
	tree->right = create_tree(a+i+1,b+i+1,size-i-1);
	return tree;
}
//前序遍历
void dlr_tree(TreeNode* tree)
{
	if(NULL == tree)
	{
		printf("#");
		return;
	}
	printf("%c",tree->data);
	dlr_tree(tree->left);
	dlr_tree(tree->right);
}
//中序遍历
void ldr_tree(TreeNode* tree)
{
	if(NULL == tree)
	{
		return;
	}
	ldr_tree(tree->left);
	printf("%c",tree->data);
	ldr_tree(tree->right);
}
//后序遍历
void lrd_tree(TreeNode* tree)
{
	if(NULL == tree)
	{
		return;
	}
	lrd_tree(tree->left);
	lrd_tree(tree->right);
	printf("%c",tree->data);
}

// 计算树的密度
size_t density_tree(TreeNode* tree)
{
	if(NULL == tree)
		return 0;
	return 1+density_tree(tree->left)+density_tree(tree->right);
}

// 计算树的高度
size_t hight_tree(TreeNode* tree)
{
	if(NULL == tree)
		return 0;
	size_t lh = hight_tree(tree->left);
	size_t rh = hight_tree(tree->right);
	return lh>rh ? lh+1 : rh+1;
}

// 判断树是否平衡
bool is_blance_tree(TreeNode* tree)
{
	if(NULL == tree)
		return true;
	int lh = hight_tree(tree->left);
	int rh = hight_tree(tree->right);
	return 1 >= abs(lh-rh) && is_blance_tree(tree->left) && is_blance_tree(tree->right);
}
//层序遍历
void level_show(TreeNode* tree)
{
	if(NULL == tree)
		return;
	
	QueueList* queue = create_queue_list();
	push_queue_list(queue,tree);

	while(!empty_queue_list(queue))
	{
		TreeNode* tree = front_queue_list(queue);
		pop_queue_list(queue);
		printf("%c ",tree->data);
		if(NULL != tree->left)
			push_queue_list(queue,tree->left);
		if(NULL != tree->right)
			push_queue_list(queue,tree->right);
	}

	destroy_queue_list(queue);
}
//比较子函数
bool cmp(TreeNode* ta,TreeNode* tb)
{
	if(NULL == tb) return true;
	if(NULL == ta) return false;
	return ta->data == tb->data && 
		   cmp(ta->left,tb->left) && 
		   cmp(ta->right,tb->right);
}
//tb是否是ta的子结构
bool is_child_struct(TreeNode* ta,TreeNode* tb)
{
	if(NULL == ta || NULL == tb)
		return false;

	bool flag = false;
	if(ta->data == tb->data)
		flag = cmp(ta,tb);
	
	return flag || is_child_struct(ta->left,tb) || is_child_struct(ta->right,tb);
}
//中序遍历子函数
void _ldr_show(TreeNode* tree,TreeNode** result)
{
	if(NULL == tree || NULL!=*result)
		return;
	_ldr_show(tree->left,result);
	if(NULL == *result)
		*result = tree;
	_ldr_show(tree->right,result);
}
//查找中序遍历第一个结点
TreeNode* first_ldr_tree(TreeNode* tree)
{
	TreeNode* result = NULL;
	_ldr_show(tree,&result);
	return result;
}
//镜像树
void mirror_tree(TreeNode* tree)
{
	if(NULL == tree)
		return;
	TreeNode* temp = tree->left;
	tree->left = tree->right;
	tree->right = temp;
	mirror_tree(tree->left);
	mirror_tree(tree->right);
}
//测试
int main(int argc,const char* argv[])
{
	/*
		 //ABDG##HI####CE#J##F##
	str = "ABDG##HI####CE#J##F##";
	TreeNode* tree = create_tree();
	ldr_tree(tree);
	printf("\n");
	lrd_tree(tree);
	*/
	char* a = "ABDGHICEJF";
	char* b = "GDIHBAEJCF";
	TreeNode* tree1 = create_tree(a,b,10);
	TreeNode* tree2 = create_tree("x","x",1);
	printf("%d\n",is_child_struct(tree1,tree1->left));
}

#ifndef QUEUE_H
#define QUEUE_H
#include <stdio.h>
#include <stdbool.h>

typedef struct Node
{
	void* data;
	struct Node* next;
}Node;

typedef struct QueueList
{
	Node* front;
	Node* rear;
}QueueList;

// 创建结点
Node* create_node(void* data);

// 创建队列
QueueList* create_queue_list(void);

// 队空
bool empty_queue_list(QueueList* queue);

// 入队
void push_queue_list(QueueList* queue,void* data);

// 出队
bool pop_queue_list(QueueList* queue);

// 队头
void* front_queue_list(QueueList* queue);

// 队尾
void* rear_queue_list(QueueList* queue);

// 队长
size_t size_queue_list(QueueList* queue);

// 销毁
void destroy_queue_list(QueueList* queue);

#endif//QUEUE_H

#include <stdlib.h>
#include "queue.h"

Node* create_node(void* data)
{
	Node* node = malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	return node;
}


// 创建队列
QueueList* create_queue_list(void)
{
	QueueList* queue = malloc(sizeof(QueueList));
	queue->front = NULL;
	queue->rear = NULL;
	return queue;
}

bool empty_queue_list(QueueList* queue)
{
	return NULL == queue->front;
}

// 入队
void push_queue_list(QueueList* queue,void* data)
{
	Node* node = create_node(data);
	if(empty_queue_list(queue))
	{
		queue->front = node;
		queue->rear = node;
	}
	else
	{
		queue->rear->next = node;
		queue->rear = node;
	}
}

bool pop_queue_list(QueueList* queue)
{
	if(empty_queue_list(queue))
		return false;

	Node* temp = queue->front;
	queue->front = temp->next;
	free(temp);
	return true;
}

void* front_queue_list(QueueList* queue)
{
	return queue->front->data;
}

void* rear_queue_list(QueueList* queue)
{
	return queue->rear->data;
}

size_t size_queue_list(QueueList* queue)
{
	size_t size = 0;
	for(Node* n=queue->front; NULL!=n; n=n->next,size++);
	return size;
}

void destroy_queue_list(QueueList* queue)
{
	while(pop_queue_list(queue));
	free(queue);
}