二叉树（C语言实现）

以下为用C语言实现的二叉排序树，包含了树的创建，销毁，添加，删除，修改，前、中、后、层序遍历，深度，密度。

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

#define TYPE int

typedef struct Node
{
	TYPE data;
	struct Node* left;
	struct Node* right;
}Node;

// 创建结点
Node* creat_node(TYPE data);
// 添加
bool add_tree(Node* root,TYPE data);
// 删除
bool del_tree(Node* root,TYPE data);
// 访问
bool access_tree(Node* root,size_t i,TYPE* p);
// 前序
void prev_show(Node* root);
// 中序
void in_show(Node* root);
// 后序
void post_show(Node* root);
// 层序
void level_show(Node* root);
// 高度
size_t high_tree(Node* root);
// 密度
size_t density_tree(Node* root);


int main()
{
	Node* tree = creat_node(50); // 创建树，根节点初始化为50
	for(int i=0; i<10; i++)
	{
		TYPE data = rand() % 100;
		printf("%d %s\n",data,add_tree(tree,data)?"成功":"失败"); // 添加节点
	}
	printf("%d\n",high_tree(tree)); // 树的高度
	printf("%d\n",density_tree(tree)); // 树的密度
}

// 创建结点
Node* creat_node(TYPE data)
{
	Node* node = malloc(sizeof(Node)); // 为节点申请一块内存
	node->data = data; // 将节点的数据域赋值为data
	node->left = NULL; // 左子树指针指向空
	node->right = NULL; // 右子树指针指向空
	return node; // 返回节点
}

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);
}

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) // 如果index等于i，说明找到要访问节点
	{
		*p = root->data; // 将节点的数据赋值给p所指向的内存
		*indexp += 1; // 将计数加1，防止递归返回的时候，再次进入
		return;
	}
	*indexp += 1;
	_access_tree(root->right,i,p,indexp); // 递归右子树
}

// 访问
bool access_tree(TreeNode* root,size_t i,TYPE_T* p) // root为要访问的树的根节点，i为要访问的第几个节点，p用来返回节点的数据
{
	size_t index = 0;
	_access_tree(root,i,p,&index);// index用于计数
	return true;
}

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

// 中序
void in_show(Node* root)
{
        if(NULL == root) return;
        prev_show(root->left);
        printf("%d ",root->data);
        prev_show(root->right);
}
// 后序
void post_show(Node* root)
{
        if(NULL == root) return;
        prev_show(root->left);
        prev_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");
}


// 高度
size_t high_tree(Node* 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;
}

// 密度
size_t density_tree(Node* root)
{
	if(NULL == root) return 0;
	return 1+density_tree(root->left)+density_tree(root->right);
}