树的存储结构实例

1.#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;
}

2.#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++)
        {
            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);
}

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

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

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

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

3。#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

4.#ifndef _LINKLIST_H_
#define _LINKLIST_H_

typedef void LinkList;
typedef struct _tag_LinkListNode LinkListNode;
struct _tag_LinkListNode
{
    LinkListNode* next;
};

LinkList* LinkList_Create();

void LinkList_Destroy(LinkList* list);

void LinkList_Clear(LinkList* list);

int LinkList_Length(LinkList* list);

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos);

LinkListNode* LinkList_Get(LinkList* list, int pos);

LinkListNode* LinkList_Delete(LinkList* list, int pos);

#endif

5.#include <stdio.h>
#include <malloc.h>
#include "LinkList.h"
/* 链表树的结构体 */
typedef struct _tag_LinkList
{
    LinkListNode header;
    int length;
} TLinkList;
//创建树
LinkList* LinkList_Create() // O(1)
{
    TLinkList* ret = (TLinkList*)malloc(sizeof(TLinkList));
    
    if( ret != NULL )
    {
        ret->length = 0;
        ret->header.next = NULL;
    }
    
    return ret;
}
//销毁树
void LinkList_Destroy(LinkList* list) // O(1)
{
    free(list);
}
//清空树
void LinkList_Clear(LinkList* list) // O(1)
{
    TLinkList* sList = (TLinkList*)list;
    
    if( sList != NULL )
    {
        sList->length = 0;
        sList->header.next = NULL;
    }
}
//获取长度
int LinkList_Length(LinkList* list) // O(1)
{
    TLinkList* sList = (TLinkList*)list;
    int ret = -1;
    
    if( sList != NULL )
    {
        ret = sList->length;
    }
    
    return ret;
}
//插入树
int LinkList_Insert(LinkList* list, LinkListNode* node, int pos) // O(n)
{
    TLinkList* sList = (TLinkList*)list;
    int ret = (sList != NULL) && (pos >= 0) && (node != NULL);
    int i = 0;
    
    if( ret )
    {
        LinkListNode* current = (LinkListNode*)sList;
        
        for(i=0; (i<pos) && (current->next != NULL); i++)
        {
            current = current->next;
        }
        
        node->next = current->next;
        current->next = node;
        
        sList->length++;
    }
    
    return ret;
}
//获取树的节点
LinkListNode* LinkList_Get(LinkList* list, int pos) // O(n)
{
    TLinkList* sList = (TLinkList*)list;
    LinkListNode* ret = NULL;
    int i = 0;
    
    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
    {
        LinkListNode* current = (LinkListNode*)sList;
        
        for(i=0; i<pos; i++)
        {
            current = current->next;
        }
        
        ret = current->next;
    }
    
    return ret;
}
//删除树的节点
LinkListNode* LinkList_Delete(LinkList* list, int pos) // O(n)
{
    TLinkList* sList = (TLinkList*)list;
    LinkListNode* ret = NULL;
    int i = 0;
    
    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
    {
        LinkListNode* current = (LinkListNode*)sList;
        
        for(i=0; i<pos; i++)
        {
            current = current->next;
        }
        
        ret = current->next;
        current->next = ret->next;
        
        sList->length--;
    }
    
    return ret;
}

时间： 2024-10-05 12:07:23

树的存储结构实例的相关文章

10.树与树的存储结构

一.树 1.树的定义:树是n(n>=0)个结点的有限集,其中n=0时称为空树.在任意一颗非空树中:(1)有且仅有一个特定的称为根的结点;(2)当n>1时,其余结点可分为m(m>0)个互不相交的有限集T1.T2.....Tm,其中每一个集合本身又是一棵树,并且称为根的子树(Subtree). 注意:当m>0时,子树的个数没有限制,但它们一定是互不相交的. 2.结点的度与树的度 树的结点包含一个数据元素及若干指向其子树的分支. (1)结点的度:结点拥有的子树称为结点的度(degree)

Java数据结构-树及树的存储结构

树的定义:n(n>=0)个节点的有限集. n=0时称为空树. n!=0时为非空树,有且仅有一个特定的节点--根:n>1时,其它节点可以分为m(m>0)个互不相交的有限集T1~Tm,其中每一个集合本身又是一棵树,并且称为根的子树. 树的一些基本术语: 树的结点:由一个数据元素和若干个指向其子树的分支组成. 结点的度:结点所拥有的子树的个数(即分支数)称为该结点的度. 叶子结点:度为0的结点称为叶子结点,或者称为终端结点. 分支结点:度不为0的结点称为分支结点,或者称为非终端结点.一棵树的结

树以及树的存储结构

//树的存储结构 //双亲存储结构 typedef struct { int data;//结点的值 int parent;//指向双亲位置的伪指针 } PTree[maxsize]; //孩子存储结构 typedef struct node { int data;//结点的值 struct node *sons[maxsize];//指向孩子结点 }TSonNode; //孩子兄弟链存储结构 typedef struct tnode { int data; struct tnode *hp;/

数据结构（四）树---树的存储结构

前提 树中的某个结点的孩子可以有多个,所以仅仅使用简单的顺序结构或者链式结构是不能完全表示一整棵树的. 充分利用顺序存储结构和链式存储结构的特点,完全可以实现对树的存储结构的表示 我们表示一棵树的方法有:双亲表示法,孩子表示法,孩子兄弟表示法 补充 对于双亲表示法:我们先将双亲结点存入,我们每插入一个结点都是知道双亲结点位置的,数据可以直接插入.使用顺序存储结构更加方便 而对于孩子表示法,我们每次插入一个结点,对其子树的位置存放暂不确定,所有使用链式存储结构占主要 (一)双亲表示法 以双亲作为索

树的存储结构以及遍历

一.树的存储结构 ——————顺序存储(一维数组)—————— 1.双亲表示法: 1 #define MaxSize 100 //假设树中最多有100个节点 2 //1.定义树节点的数据类型,假设为char型 3 typedef char DataType; 4 typedef struct{ 5 DataType data; //树节点的数据信息 6 int parent; //该节点的双亲在数组中的下标 7 }PNode; 8 //2.定义双亲表示法存储结构 9 typedef struct

树——通用树的存储结构与结点实现

1,上篇博文介绍了树的定义和相关概念定义,本节课创建树对象和树结点对象: 2,课程目标: 1,完成树和结点的存储结构设计: 1,没有树结点,就没有树,同生死: 3,设计要点: 1,GTree 为通用树结构,每个结点可以存在多个后继结点: 2,GTreeNode 能够包含任意多指向后继结点的指针: 3,实现树结构的所有操作(增,删,查,等): 1,抽象类只用包含功能函数,具体的对象才包含成员变量和实现功能函数: 4,GTreeNode 的设计与实现: 1,组合单链表类,因为要包含任意多指向结点的指

树的存储结构

////////////////////////////////树的双亲孩子结构/////////////////////////////#include<iostream>using namespace std; #define MAX_TREE_SIZE 100typedef int ELEMTYPE ; //孩子结点typedef struct TNode{ int child;//孩子结点的下标 struct TNode *next;}*ChildPtr; //表头结构typedef

第五十二课 树的存储结构与实现

GTree是通用树结构. 每个节点都包含了指向父节点的指针. 添加GTreeNode.h文件: 1 #ifndef GTREENODE_H 2 #define GTREENODE_H 3 4 #include "TreeNode.h" 5 #include "LinkList.h" 6 7 namespace DTLib 8 { 9 10 template < typename T > 11 class GTreeNode : public TreeNo

数据结构--树（定义与存储结构）

树基本定义 树的定义 数是具有n个节点的有限集.如图即是一个树形结构. 节点分类 节点的度:一个节点拥有的子节点即成为节点的度,比如A节点,有B和C两个子节点,那么A节点的度=2. 叶节点(终端节点):没有子节点的节点,比如G.H.I.... 如图: 节点间关系 孩子节点:某一个节点的子节点称为孩子节点.比如B.C节点是A节点的孩子节点. 双亲节点:与孩子节点相反.比如,A节点是B.C的双亲节点. 兄弟节点:同一个双亲节点的孩子节点,之间称为兄弟节点.比如,B.C为兄弟节点. 如图: 树的存储结