【l练习代码】有序二叉树的操作

主要实现功能为：增加节点，计算二叉树节点的个数，删除二叉树指定的节点，镜像二叉树的实现（变成镜像二叉树后不再是有序二叉树，所以不能删除节点）。

最近学习中发现二叉树还是挺有意思的，上网看了下二叉树的操作，发现比我想象中的要多得多，不仅仅是二叉树的增删改查，但有些的确是有难度，虽然想好好掌握以下，但暂时还是把精力放到能短时间领悟的知识上。

#include <stdio.h>
#include <stdlib.h>

typedef struct _node
{
	int data;
	struct _node* p_left;
	struct _node* p_right;
}Node;

typedef struct _tree
{
	Node* p_root;
}Tree;

//创建一棵二叉树
void create_tree(Tree **pp_tree)
{
	*pp_tree = (Tree*)malloc(sizeof(Tree));
	(*pp_tree)->p_root = NULL;
}

//创建一个节点
Node* create_node(int data)
{
	Node* p_node = (Node*)malloc(sizeof(Node));
	p_node->data = data;
	p_node->p_right = NULL;
	p_node->p_left = NULL;
	return p_node;
}

//插入一个节点
void insert_node(Node** pp_tree_root, Node* p_node)
{
	if (NULL == *pp_tree_root)
	{
		*pp_tree_root = p_node;
		return;
	}

	if ((*pp_tree_root)->data > p_node->data)
	{
		insert_node(&(*pp_tree_root)->p_left, p_node);
	}
	else
	{
		insert_node(&(*pp_tree_root)->p_right, p_node);
	}
}

//寻找一个节点，返回值为这个节点的地址的地址(指向该节点的指针的地址）
Node** find_node(Node** pp_tree_root, int data)
{
	if (data == (*pp_tree_root)->data)
	{
		return pp_tree_root;
	}
	else if (NULL == (*pp_tree_root))
	{
		return pp_tree_root;
	}
	else if (data < (*pp_tree_root)->data)
	{
		find_node(&(*pp_tree_root)->p_left, data);
	}
	else
	{
		find_node(&(*pp_tree_root)->p_left, data);
	}
}

//删除二叉树中指定的节点，参数一为二叉树的跟节点，参数二为要删除的节点里的数据
int delete_node(Node** pp_tree_root, int data)
{
	Node** pp_node = find_node(pp_tree_root, data);
	if (NULL == *pp_node)
	{
		return 0;
	}

	if (NULL != (*pp_node)->p_left)
	{
		insert_node(&(*pp_node)->p_right, (*pp_node)->p_left);
	}
	Node* temp = *pp_node;
	*pp_node = (*pp_node)->p_right;
	free(temp);
	temp = NULL;

	return 1;
}

//镜像二叉树的调用函数
Node* image(Node* p_node)
{
	if (NULL == p_node)	
	{
		return NULL;
	}
	Node* p_left = image(p_node->p_left);
	Node* p_right = image(p_node->p_right);
	
	p_node->p_left = p_right;
	p_node->p_right = p_left;
	return p_node;
}

//实现镜像二叉树
void image_tree(Node** pp_tree_root, int data)
{
	Node **pp_node = find_node(pp_tree_root, data);
	if (NULL == *pp_node)
	{
		return;
	}
	image(*pp_node);
}

//计算二叉树节点的个数
int get_size(Node* p_node)
{
	if (NULL == p_node)
	{
		return 0;
	}
	int l_size = get_size(p_node->p_left);
	int r_size = get_size(p_node->p_right);

	return l_size + r_size + 1;
}

//打印二叉树
void print(Node* p_node, int level)
{
	if (NULL == p_node)
	{
		return;
	}
	print(p_node->p_right, level + 1);
	int i = 0;
	for (i = 0; i < level; i++)
	{
		printf("   ");
	}
	printf("%d\n", p_node->data);
	print(p_node->p_left, level + 1);
}

//测试代码
int main(void)
{
	Tree* tree = NULL;
	create_tree(&tree);
	int arr[9] = {55, 44, 66, 33, 77, 99, 11, 22, 88,};
	int i = 0;
	for (i = 0; i < 9; i++)
	{
		insert_node(&tree->p_root, create_node(arr[i]));
	}
	printf("节点个数为: %d\n", get_size(tree->p_root));
	print(tree->p_root, 0);
	printf("---------------------------\n");
	//image_tree(&tree->p_root, 44);
	//print(tree->p_root, 0);
	//delete_node(&tree->p_root, 33);
	print(tree->p_root, 0);
	printf("节点个数为: %d\n", get_size(tree->p_root));
}