数据结构封装之《GTree通用树》

说明：

代码：

#ifndef _GTREE_H_
#define _GTREE_H_

typedef void GTree;
typedef void GTreeData;
typedef void (GTree_Printf)(GTreeData*);

GTree* GTree_Create();

void GTree_Destroy(GTree* tree);

void GTree_Clear(GTree* tree);

int GTree_Insert(GTree* tree, GTreeData* data, int pPos);

GTreeData* GTree_Delete(GTree* tree, int pos);

GTreeData* GTree_Get(GTree* tree, int pos);

GTreeData* GTree_Root(GTree* tree);

int GTree_Height(GTree* tree);

int GTree_Count(GTree* tree);

int GTree_Degree(GTree* tree);

void GTree_Display(GTree* tree, GTree_Printf* pFunc, int gap, char div);

#endif

#include <stdio.h>
#include <malloc.h>
#include "GTree.h"
#include "LinkList.h"

typedef struct _tag_GTreeNode GTreeNode;
struct _tag_GTreeNode
{
GTreeData* data;
GTreeNode* parent;
LinkList* child;
};

typedef struct _tag_TLNode TLNode;
struct _tag_TLNode
{
LinkListNode header;
GTreeNode* node;
};

static void recursive_display(GTreeNode* node, GTree_Printf* pFunc, int format, int gap, char div)
{
int i = 0;

if( (node != NULL) && (pFunc != NULL) )
{
for(i=0; i<format; i++)
{
printf("%c", div);
}

pFunc(node->data);

printf("\n");

for(i=0; i<LinkList_Length(node->child); i++)
e657
{
TLNode* trNode = (TLNode*)LinkList_Get(node->child, i);

recursive_display(trNode->node, pFunc, format + gap, gap, div);
}
}
}

static void recursive_delete(LinkList* list, GTreeNode* node)
{
if( (list != NULL) && (node != NULL) )
{
GTreeNode* parent = node->parent;
int index = -1;
int i = 0;

for(i=0; i<LinkList_Length(list); i++)
{
TLNode* trNode = (TLNode*)LinkList_Get(list, i);

if( trNode->node == node )
{
LinkList_Delete(list, i);

free(trNode);

index = i;

break;
}
}

if( index >= 0 )
{
if( parent != NULL )
{
for(i=0; i<LinkList_Length(parent->child); i++)
{
TLNode* trNode = (TLNode*)LinkList_Get(parent->child, i);

if( trNode->node == node )
{
LinkList_Delete(parent->child, i);

free(trNode);

break;
}
}
}

while( LinkList_Length(node->child) > 0 )
{
TLNode* trNode = (TLNode*)LinkList_Get(node->child, 0);

recursive_delete(list, trNode->node);
}

LinkList_Destroy(node->child);

free(node);
}
}
}

static int recursive_height(GTreeNode* node)
{
int ret = 0;

if( node != NULL )
{
int subHeight = 0;
int i = 0;

for(i=0; i<LinkList_Length(node->child); i++)
{
TLNode* trNode = (TLNode*)LinkList_Get(node->child, i);

subHeight = recursive_height(trNode->node);

if( ret < subHeight )
{
ret = subHeight;
}
}

ret = ret + 1;
}

return ret;
}

static int recursive_degree(GTreeNode* node)
{
int ret = -1;

if( node != NULL )
{
int subDegree = 0;
int i = 0;

ret = LinkList_Length(node->child);

for(i=0; i<LinkList_Length(node->child); i++)
{
TLNode* trNode = (TLNode*)LinkList_Get(node->child, i);

subDegree = recursive_degree(trNode->node);

if( ret < subDegree )
{
ret = subDegree;
}
}
}

return ret;
}

/* 创建树 */
GTree* GTree_Create()
{
return LinkList_Create();
}
/* 销毁已存在的树 */
void GTree_Destroy(GTree* tree)
{
GTree_Clear(tree);
LinkList_Destroy(tree);
}
/* 将已存在的树清空为空树 */
void GTree_Clear(GTree* tree)
{
GTree_Delete(tree, 0);
}
/* 将结点node插入到tree中的pos位置处 */
int GTree_Insert(GTree* tree, GTreeData* data, int pPos)
{
LinkList* list = (LinkList*)tree;
int ret = (list != NULL) && (data != NULL) && (pPos < LinkList_Length(list));

if( ret )
{
TLNode* trNode = (TLNode*)malloc(sizeof(TLNode));//创建当前树节点
TLNode* cldNode = (TLNode*)malloc(sizeof(TLNode));//向树链表中要插入的链表节点
TLNode* pNode = (TLNode*)LinkList_Get(list, pPos);//向父节点的孩子链表中要插入的链表节点
GTreeNode* cNode = (GTreeNode*)malloc(sizeof(GTreeNode));//父节点中的孩子链表

ret = (trNode != NULL) && (cldNode != NULL) && (cNode != NULL);

if( ret )
{
cNode->data = data;
cNode->parent = NULL;
cNode->child = LinkList_Create();

trNode->node = cNode;
cldNode->node = cNode;

LinkList_Insert(list, (LinkListNode*)trNode, LinkList_Length(list));

if( pNode != NULL )
{
cNode->parent = pNode->node;

LinkList_Insert(pNode->node->child, (LinkListNode*)cldNode, LinkList_Length(pNode->node->child));
}
}
else
{
free(trNode);
free(cldNode);
free(cNode);
}
}

return ret;
}
/* 将tree中pos位置的结点删除并返回 */
GTreeData* GTree_Delete(GTree* tree, int pos)
{
TLNode* trNode = (TLNode*)LinkList_Get(tree, pos);
GTreeData* ret = NULL;

if( trNode != NULL )
{
ret = trNode->node->data;

recursive_delete(tree, trNode->node);
}

return ret;
}
/* 将tree中pos位置的结点返回 */
GTreeData* GTree_Get(GTree* tree, int pos)
{
TLNode* trNode = (TLNode*)LinkList_Get(tree, pos);
GTreeData* ret = NULL;

if( trNode != NULL )
{
ret = trNode->node->data;
}

return ret;
}
/* 返回tree的根结点 */
GTreeData* GTree_Root(GTree* tree)
{
return GTree_Get(tree, 0);
}

/* 返回tree的高度 */
int GTree_Height(GTree* tree)
{
TLNode* trNode = (TLNode*)LinkList_Get(tree, 0);
int ret = 0;

if( trNode != NULL )
{
ret = recursive_height(trNode->node);
}

return ret;
}
/* 返回树的结点数 */
int GTree_Count(GTree* tree)
{
return LinkList_Length(tree);
}
/* 返回树的度数 */
int GTree_Degree(GTree* tree)
{
TLNode* trNode = (TLNode*)LinkList_Get(tree, 0);
int ret = -1;

if( trNode != NULL )
{
ret = recursive_degree(trNode->node);
}

return ret;
}
/*展示树，pFunc为输出函数指针，gap为填充字符的个数，dix指定填充字符*/
void GTree_Display(GTree* tree, GTree_Printf* pFunc, int gap, char div)
{
TLNode* trNode = (TLNode*)LinkList_Get(tree, 0);

if( (trNode != NULL) && (pFunc != NULL) )
{
recursive_display(trNode->node, pFunc, 0, gap, div);
}
}

#include <stdio.h>
#include "GTree.h"

void printf_data(GTreeData* data)
{
printf("%c", (int)data);
}

int main(int argc, char *argv[])
{
GTree* tree = GTree_Create();
int i = 0;

GTree_Insert(tree, (GTreeData*)'A', -1);
GTree_Insert(tree, (GTreeData*)'B', 0);
GTree_Insert(tree, (GTreeData*)'C', 0);
GTree_Insert(tree, (GTreeData*)'D', 0);
GTree_Insert(tree, (GTreeData*)'E', 1);
GTree_Insert(tree, (GTreeData*)'F', 1);
GTree_Insert(tree, (GTreeData*)'H', 3);
GTree_Insert(tree, (GTreeData*)'I', 3);
GTree_Insert(tree, (GTreeData*)'J', 3);

printf("Tree Height: %d\n", GTree_Height(tree));
printf("Tree Degree: %d\n", GTree_Degree(tree));
printf("Full Tree:\n");

GTree_Display(tree, printf_data, 2, ' ');

printf("Get Tree Data:\n");

for(i=0; i<GTree_Count(tree); i++)
{
printf_data(GTree_Get(tree, i));
printf("\n");
}

printf("Get Root Data:\n");

printf_data(GTree_Root(tree));

printf("\n");

GTree_Delete(tree, 3);

printf("After Deleting D:\n");

GTree_Display(tree, printf_data, 2, '-');

GTree_Clear(tree);

printf("After Clearing Tree:\n");

GTree_Display(tree, printf_data, 2, '.');

GTree_Destroy(tree);

return 0;
}

函数结构分析：

汇编分析：