#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;
}
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);
}
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[])
{
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
#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);
}