数据结构（树）

树

树是一种非线性的数据结构
根节点：没有父结点的结点
叶节点：没有结节点的节点，度为0的结点
分支节点：有结点的节点，度非0的结点
子节点
父节点
树的度：所有结点中度的最大值
树的高度 = 树的层次

二叉树

二叉树
树的度最大为2的树
满二叉树：所有结点度为2
完全二叉树：允许缺结点，按顺序去（最后往前删）
性质1：
在二叉树的第n层最多有2^(n-1)个结点点
性质2：
高度为k的二叉树最多有2^k-1个结点
性质3：
度为2的结点个数+1= 度为0的节点个数
性质4：
n个节点
高度为Log2n的+1；
回调函数：用函数指针传递
二叉树的遍历：（递归）
1、前序遍历
任何一个结点遍历满足根、左、右的规律。
2、中序遍历
任何一个结点遍历满足左、根、右的规律。
3、后序遍历
任何一个结点遍历满足左、右。根的规律。
4、层遍历

代码

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

//创建空的树
BTree *Create()		
{
	BTree *btree = (BTree *)malloc(sizeof(BTreeNode)/sizeof(char));
	if(NULL == btree)
		return;
	
	return btree;
}

//插入数据
BOOL Inster(BTree *btree,BTreedata data,int way,int steps,MOUNTWAY mw)
{
	if(NULL == btree)
		return FALSE;
	
	BTreeNode *node = (BTreeNode *)malloc(sizeof(BTreeNode)/sizeof(char));
	if(NULL == node)
		return FALSE;
	
	node->lchild = NULL;
	node->rchild = NULL;
	node->data   = data;
	
	int waynode = 0;
	BTreeNode *tmp = btree->root;	//当前要插入的结点
	BTreeNode *parent = NULL;		//父结点
	
	while(tmp != NULL && steps > 0)
	{
		waynode = way&1;
		way >>= 1;
		parent = tmp;
		if(LEFT == waynode)
			tmp = tmp->lchild;
		else
			tmp = tmp->rchild;
		steps--;
	}
	
	if(LEFT == mw)					//将原来结点挂载到新结点下
		node->lchild = tmp;
	else
		node->rchild = tmp;
	
	if(parent != NULL)
	{
		if(LEFT == waynode)				//将插入的结点挂载到原来的结点上
			parent->lchild = node;
		else
			parent->rchild = node;
	}
	else
		btree->root = node;
	
	return TRUE;
}

//删除的递归函数
void r_delete(BTreeNode *tmp)
{
	if(NULL == tmp)
		return;
	
	r_delete(tmp->lchild);	//释放左结点
	r_delete(tmp->rchild);	//释放右结点
	free(tmp);					//释放自己
}

BOOL Delete(BTree *btree,int way,int steps)
{
	if(NULL == btree)
		return FALSE;
	
	int waynode = 0;
	BTreeNode *tmp = btree->root;
	BTreeNode *parent = NULL;
	
	while(steps > 0 && tmp != NULL)
	{
		waynode = way&1;
		way >>= 1;
		parent = tmp;
		if(LEFT == waynode)
			tmp = tmp->lchild;
		else
			tmp = tmp->rchild;
		steps--;
	}
	if(parent != NULL)
	{
		if(LEFT == waynode)
			parent->lchild = NULL;
		else
			parent->rchild = NULL;
	}
	else
		btree->root =NULL;
	
	r_delete(tmp);
	
	return TRUE;
}

//打印的递归
void r_display(BTreeNode *node,PFUNC callback,int level)
{		
	callback(node,level);
	//打印自己
	if(NULL == node)
		return;
	if(node->lchild != NULL || node->rchild != NULL)
	{
		//打印左结点
		r_display(node->lchild,callback,level+1);
		//打印右结点
		r_display(node->rchild,callback,level+1);
	}
}

void Btree_display(BTree *btree,PFUNC callback)
{
	if(NULL == btree)
		return;
	
	r_display(btree->root,callback,1);
}

//计算结点
int r_count(BTreeNode *node)
{
	if(NULL == node)
		return 0;
	int lc = r_count(node->lchild);			//左子树的结点
	int rc = r_count(node->rchild);			//右子树的结点
	
	return lc+rc+1;
}

int Count(BTree *btree)
{
	if(NULL == btree)
		return 0;
	
	r_count(btree->root);
}

//计算高度
int r_height(BTreeNode *node)
{
	if(NULL == node)
		return 0;
	
	int lh = r_height(node->lchild);		//左子树的高度
	int rh = r_height(node->rchild);		//右子树的高度
	
	return (lh>rh?lh:rh)+1;
}

int Height(BTree *btree)
{
	if(NULL == btree)
		return 0;
	
	r_height(btree->root);
}

//计算树的度
int r_degree(BTreeNode *node)
{
	if(NULL == node)
		return 0;
	
	int degree = 0;
	if(node->lchild != NULL)
		degree++;
	if(node->rchild != NULL)
		degree++;
	
	if(degree != 2)
	{
		int ldegree = r_degree(node->lchild);			//左子树的度
		int rdegree = r_degree(node->rchild);			//右子树的度
	
		if(degree < ldegree)
			degree = ldegree;
		if(degree < rdegree)
			degree = rdegree;
	}
	
	return degree;
}

int Degree(BTree *btree)
{
	if(NULL == btree)
		return 0;
	
	r_degree(btree->root);
}

//销毁树
void deport(BTree *btree)
{
	if(NULL == btree)
		return;
	
	r_delete(btree->root);
	free(btree);
}

//前序遍历
void pet_pos(BTreeNode *node)
{
	if(NULL == node)
		return;
	printf("%2c",node->data);//根
	pet_pos(node->lchild);//左
	pet_pos(node->rchild);//右
}

//中序遍历
void mid_pos(BTreeNode *node)
{
	if(NULL == node)
		return;
	mid_pos(node->lchild);//左
	printf("%2c",node->data);//根
	mid_pos(node->rchild);//右
}

//后序遍历
void last_pos(BTreeNode *node)
{
	if(NULL == node)
		return;
	last_pos(node->lchild);//左
	last_pos(node->rchild);//右
	printf("%2c",node->data);//根
}


//遍历
void pos(BTree *btree)
{
	if(NULL == btree)
		return;
	
	//前序遍历
	printf("前序遍历:");
	pet_pos(btree->root);
	printf("\n");
	//中序遍历
	printf("中序遍历:");
	mid_pos(btree->root);
	printf("\n");
	//后序遍历
	printf("后序遍历:");
	last_pos(btree->root);
	printf("\n");
}