樹的儲存結構

無法直接用陣列表示樹的邏輯結構
但可以設計結構體陣列對結點間的關係進行表述

如下圖所示：

利用連結串列組織樹中的各個結點。
連結串列中的前後關係不代表結點間的邏輯關係。
結點的邏輯關係由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;
}

小結

本節中的樹結構是一種通用的資料結構。

利用連結串列組織樹結點能夠便利的存取結點，但是連結串列的維護具有一定複雜性。

樹結構的非線性特性和遞迴定義的特性是樹結構實現難度較大的根本原因。