数据结构day7

二叉树的存储：

顺序存储二叉树

   必须按照完全二叉树的顺序格式存储节点数据，如果有空位置则使用特殊数据代替，保证形成完全二叉树

        数据项：

            存储节点的内存首地址

            容量

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

#define TREE_TYPE char
#define EMPTY '#'
#define PH "%c "

//	顺序存储二叉树结构
typedef struct BinTree
{
	TREE_TYPE* arr;
	size_t cal;
}BinTree;

//	通过以完全二叉树格式层序遍历的结果来构建二叉树
BinTree* create_tree(TREE_TYPE* arr,size_t len)
{
	BinTree* tree = malloc(sizeof(BinTree));
	tree->arr = malloc(sizeof(TREE_TYPE)*len);
	tree->cal = len;
	memcpy(tree->arr,arr,len*sizeof(TREE_TYPE));
	return tree;
}

//	从tree的编号为number的节点开始 进行前序遍历
void _dlr_show(BinTree* tree,size_t number)
{
	if(0 == number || number > tree->cal 
			|| EMPTY == tree->arr[number-1]) return;
	//	编号与下标差1
	//	遍历根
	printf("%c ",tree->arr[number-1]);
	//	遍历左
	_dlr_show(tree,number*2);
	//	遍历右
	_dlr_show(tree,number*2+1);
}
//	前序
void dlr_show(BinTree* tree)
{
	_dlr_show(tree,1);
	printf("\n");
}

void _ldr_show(BinTree* tree,size_t number)
{
	if(0 == number || number > tree->cal 
			|| EMPTY == tree->arr[number-1]) return;
	_ldr_show(tree,number*2);
	printf(PH,tree->arr[number-1]);
	_ldr_show(tree,number*2+1);
}

//	中序
void ldr_show(BinTree* tree)
{
	_ldr_show(tree,1);	
	printf("\n");
}

void _lrd_show(BinTree* tree,size_t number)
{
	if(0 == number || number > tree->cal 
			|| EMPTY == tree->arr[number-1]) return;
	_lrd_show(tree,number*2);
	_lrd_show(tree,number*2+1);
	printf(PH,tree->arr[number-1]);
}
//	后序
void lrd_show(BinTree* tree)
{
	_lrd_show(tree,1);	
	printf("\n");
}

//	层序遍历
void layer_show(BinTree* tree)
{}
//	树的高度
int hight_tree(BinTree* tree)
{}
// 	树的密度
int density_tree(BinTree* tree)
{}


int main(int argc,const char* argv[])
{
	char* str = "ABCDE#FG#HI";	
	BinTree* tree = create_tree(str,strlen(str));	
	dlr_show(tree);
	ldr_show(tree);
	lrd_show(tree);
}

运行结果
A B D G E H I C F 
G D B H E I A C F 
G D H I E B F C A 

链式存储二叉树

    链式二叉树由一个个节点组成，每个节点的指针域指向左子树、右子树

    节点的数据项：

        数据域

        左子树指针

        右子树指针

    ABDG###EH##I##C#F##

#include <stdio.h>

#include <stdlib.h>

#include <stdbool.h>



#define TREE_TYPE char

#define PH "%c "

#define EMPTY '#'



// 设计二叉树节点

typedef struct TreeNode

{

	TREE_TYPE data;

	struct TreeNode* left;

	struct TreeNode* right;

}TreeNode;



// 创建节点

TreeNode* create_tree_node(TREE_TYPE data)

{

	TreeNode* node=malloc(sizeof(TreeNode));

	node->data=data;

	node->left=NULL;

	node->right=NULL;

	return node;

}



// 按前序构建一棵树  返回该树的根节点

TreeNode* create_dlr_tree(void)

{

	TREE_TYPE data=0;

	scanf("%c",&data);

	if(EMPTY==data) return NULL;



	TreeNode* node=create_tree_node(data);

	node->left=create_dlr_tree();

	node->right=create_dlr_tree();

	return node;

}



//   依赖函数 指针的指向发生变化

TreeNode* _create(const char** str)

{

	if(EMPTY==**str||'\0'==**str) return NULL;

	TreeNode* node=create_tree_node(**str);

	*str+=1;

	node->left=_create(str);

	*str+=1;

	node->right=_create(str);

	return node;

}



//  由调用者提供的前序遍历的结果 构建二叉树

TreeNode* create_dlr_tree_str(const char* str)

{

	_create(&str);

}



// 前序遍历

void dlr_show(TreeNode* root)

{

	if(NULL==root) return;

	printf(PH,root->data);

	dlr_show(root->left);

	dlr_show(root->right);

}



// 中序遍历

void ldr_show(TreeNode* root)

{

	if(NULL==root) return;

	ldr_show(root->left);

	printf(PH,root->data);

	ldr_show(root->right);

}



// 后序遍历

void lrd_show(TreeNode* root)

{

	if(NULL==root) return;

	lrd_show(root->left);

	lrd_show(root->right);

	printf(PH,root->data);

}



// 求高度

int high_tree(TreeNode* root)

{

	if(NULL==root) return 0;

	int lh=high_tree(root->left);

	int rh=high_tree(root->right);

	return lh>rh?lh+1:rh+1;

}



// 求密度

int density_tree(TreeNode* root)

{

	if(NULL==root) return 0;

	int l=density_tree(root->left);

	int r=density_tree(root->right);

	return l+r+1;

}



//插入

bool insert_tree(TreeNode* root,TREE_TYPE pdata,TREE_TYPE data)

{

	if(NULL==root) return false;

	if(root->data==pdata)

	{

		if(NULL==root->left)

		{

			TreeNode* node=create_tree_node(data);

			root->left=node;

			return true;

		}

		if(NULL==root->right)

		{

			TreeNode* node=create_tree_node(data);

			root->right=node;

			return true;

		}

		return false;

	}

	return insert_tree(root->left,pdata,data) 

		|| insert_tree(root->right,pdata,data);

}



// 删除

bool delete_tree(TreeNode** root,TREE_TYPE data)

{

	if(NULL==*root) return false;

	if((*root)->data==data && NULL==(*root)->left && NULL==(*root)->right)

	{

		free(*root);

		*root=NULL;

		return true;

	}

	return delete_tree(&((*root)->left),data)

		|| delete_tree(&((*root)->right),data);

}



int main(int argc,const char* argv[])

{

//	TreeNode* root=create_dlr_tree();

	TreeNode* root=create_dlr_tree_str("ABDG###EH##I##C#F##");

	insert_tree(root,'C','P');

	delete_tree(&root,'P');

	dlr_show(root);

	printf("\n");

	ldr_show(root);

	printf("\n");

	lrd_show(root);

	printf("\n");

	printf("hight:%d\n",high_tree(root));

	printf("density:%d\n",density_tree(root));

	return 0;

}

运行结果
A B D G E H I C F 
G D B H E I A C F 
G D H I E B F C A 
hight:4
density:9