树 的 存储结构 和 代码实现

树的存储结构

无法直接用数组表示树的逻辑结构
但可以设计结构体数组对结点间的关系进行表述

如下图所示：

利用链表组织树中的各个结点。
链表中的前后关系不代表结点间的逻辑关系。
结点的逻辑关系由child数据域描述
child数据域保存子结点的存储地址

节点的定义如下所示：

树中每一个结点包含一个指向父结点的指针

注意：
树结点在链表中的位置不代表树的任何逻辑关系。
树中每一个结点都是同一个链表中的数据元素。

树的详细结构图：

代码编写：通用树结构的创建

树结构代码需要用到单链表的相关头文件和源文件。

//通用树结构 头文件 GTree.h
#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

//通用树结构 源文件 GTree.c
#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);
static void recursive_delete(LinkList* list, GTreeNode* node);
static int recursive_height(GTreeNode* node);
static int recursive_degree(GTreeNode* node);

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

int GTree_Insert(GTree* tree, GTreeData* data, int pPos)
//在树中插入节点，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;
}

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

GTreeData* GTree_Root(GTree* tree)
//返回树结构中根节点的数据 
{
return GTree_Get(tree, 0);
}

int GTree_Count(GTree* tree)
//求树结构中节点的个数 
{
return LinkList_Length(tree);
}

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

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_Degree(GTree* tree)
//求树结构的度，子节点的最大数目 
{
    TLNode* trNode = (TLNode*)LinkList_Get(tree, 0);
    int ret = -1;

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

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

static void recursive_display(GTreeNode* node, GTree_Printf* pFunc, int format, int gap, char div)
//node表示需要打印的节点，pFunc为打印函数的指针，也就是函数名， 
//format为当前节点缩进的字节数，gap是每一层节点的缩进值步进值，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++)//打印该节点的子节点，递归 
        {
            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;
}

//main函数 main.c
#include <stdio.h>
#include "GTree.h"

void printf_data(GTreeData* data)//定义函数 
{
printf("%c", (int)data);//此处要用int，不能用char 
}

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

小结

本节中的树结构是一种通用的数据结构。

利用链表组织树结点能够便利的存取结点，但是链表的维护具有一定复杂性。

树结构的非线性特性和递归定义的特性是树结构实现难度较大的根本原因。