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

最新推荐文章于 2021-04-08 09:33:45 发布
最新推荐文章于 2021-04-08 09:33:45 发布
阅读量1.8k 收藏 4
点赞数 6
分类专栏： 数据与数据库 汇编（逆向） 文章标签： 数据结构 汇编 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BeiJiaan/article/details/77823443
版权

说明：

  1. 本通用树复用了LinkList的代码，采用双亲孩子法实现；

  2. 通过复用LinkList的方法封装的GTree，请看：数据结构封装之《LinkList单向链表》

下面将给出该数据结构的代码，每个函数的结构分析 ，以及个别主要函数的汇编分析

代码：

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)
{
    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);
}
/* 将结点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);
    }
}

main.c

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

函数结构分析：

1.GTree_Create

2.GTree_Clear

3.GTree_Insert

4.GTree_Delete

5.GTree_Get

6.GTree_Root

7.GTree_Height

8.GTree_Count

9.GTree_Degree

汇编分析：

main

1.GTree_Create

2.GTree_Insert

3.GTree_Delete

4.GTree_Get

5.GTree_Root

6.GTree_Height

7.GTree_Count

8.GTree_Degree

9.GTree_Display

BeiJiaan
关注
  • 6
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
通用树的实现
lzjsqn的专栏
05-16 624
单链表 #ifndef __LINKLIST_H__ #define __LINKLIST_H__ typedef void LinkList;//链表的数据封装 typedef struct _tag_LinkListNode LinkListNode;//指针域的重命名，指针域的定义最重要，在链表中遍历节点的时候就是利用指针域的移动， //他既包含了当前节点的地址信息，由于它是结构体，所以
数据结构通用树
wangzhencu的博客
05-23 674
今天来看大家介绍树，树是一种非线性的数据结构，树是由n个结点组成的有限集合，如果n=0,称为空树；如果n>0，则：有一个特定的称之为根的结点，它只有直接后继，但没有直接前驱；除根以外的其他结点划分为m个互不相交的有限集合，每个集合又是一棵树，并且称之为根的子树。       如图                      树的一些基本概念 l
G - Tree of Tree（树形背包DP）
qq_44293044的博客
08-02 266
You’re given a tree with weights of each node, you need to find the maximum subtree of specified size of this tree. Tree Definition A tree is a connected graph which contains no cycles. Input There ar...
通用树--GTree（双亲孩子法）
daa20的专栏
03-28 1976
//-- LinkList.h #ifndef _LINKLIST_H_ #define _LINKLIST_H_ typedef void LinkList; typedef struct _tag_LinkListNode LinkListNode; struct _tag_LinkListNode { LinkListNode* next; }; LinkList* LinkList
安卓如何实现多级结构树_数据结构-树（树基本实现C++）
weixin_39533432的博客
11-28 137
​树形结构是一种重要的非线性数据结构。其中树和二叉树最为常用，直观看来树是以分支关系定义的层次结构。树形结构是我们平时比较熟悉的，比如文件夹目录、公司组织关系等。在计算机领域也得到广泛的应用，编译程序就是以树来表示源程序的语法结构。二叉树是一种特殊的树形结构，他的特点是每个节点至多只有两颗子树，并且，子树有左右之分，顺序不能颠倒。树形结构里边还有很多的知识点，我不在这里做文字上的解释，这里只是针对...
Java数据封装树形结构代码实例
08-25
主要介绍了Java数据封装树形结构代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Python数据结构之链表实现
最新发布
02-27
1.使用Python语言实现链表数据结构 2.基于类封装思想 3.实现链表增删改查功能 4.有测试数据
Go-Golang一些基础数据结构的封装比如treebitmap等
08-14
Golang一些基础数据结构的封装比如tree，bitmap等
JavaScript 处理树数据结构的方法示例
12-11
JavaScript 处理树结构数据 场景 即便在前端，也有很多时候需要操作 树结构 的情况，最典型的场景莫过于 无限级分类。之前吾辈曾经遇到过这种场景，但当时没有多想直接手撕 JavaScript 列表转树了，并没有想到进行...
数据结构与算法:单向链表实现与封装
08-26
今天小编就为大家分享一篇关于数据结构与算法:单向链表实现与封装，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
通用树结构——GTree、GTreeNode
Es_Study_Yu的博客
04-03 1526
  通用树结构工程量比较大，我没时间把每一个点扩展开，详细的附上说明与过程。我浓缩了下步骤，过程全部体现在代码与注释里了。所以希望阅读的小伙伴可以按一个目录为一章的心态，根据目录的顺序与讲解，对照代码一点点的去理解。   其中因为继承，也涉及了Tree与TreeNode中的成员变量，所以对照抽象父类来阅读会更加方便。（https://blog.csdn.net/Es_Study_Yu/articl...
最短路径算法/最快路径算法--G-tree/TD-Gtree
nccccc12345的博客
04-08 2375
G-tree/TD-Gtree G-tree是由清华大学的李国良老师在2015年提出，发表论文在当年的TKDE中，并且在2019年将其扩展到时间依赖环境下，发表在当年的VLDB中。 G-tree的主要思路是将路网划分为若干个大小几乎相同子图，并且为子图创建一棵树。划分子图的大小是由两个参数来确定的：kl和kf，其中kl 用来控制叶子节点中，也就是最终划分完之后，每个子图中路网节点的个数。kf用来控制划分子图时，将一个大子图划分为几个小子图，例如kf=4，那么在划分下一级子图时，就是对每个当前子图切两刀，将每
G. Tree Reconstruction
newhonor
04-08 191
http://codeforces.com/gym/101911/problem/G 题意：删除边i能使得两个互不连通的最大节点为x，y；构造这样的树，不行就输出NO； 思路：必定有一个最大点位n；所以每次都和n连，当遇到相同的点就看有没有小与该点的节点，有就是要插进她们之间，没有则无解； #include<algorithm> #include<set> #in...
2018年全国多校算法寒假训练营练习比赛（第五场）G-Tree Recovery
albertluf的博客
02-26 269
链接：https://www.nowcoder.com/acm/contest/77/H来源：牛客网题目描述 You have N integers, A1, A2, ... , AN. You need to deal with two kinds of operations. One type of operation is to add some given number to each ...
【数据结构-G】树以及二叉树的基本概念
weixin_44768184的博客
05-21 467
目录： 树的基本概念及结构 树的相关概念 树的表示方法 二叉树的基本概念以及特性 二叉树以及满二叉树的概念 二叉树的性质 二叉树的存储方式 1、树的基本概念 树是一种非线性的数据结构，它由n(n>=0)有限节点组成一个具有层次结构的集合。把它叫做树，是因为它看起来像一个倒挂的数，也就是说它是根朝上的，而叶是朝下的。它具有以下的特点：每个结点有零个或多个子节点；没有父节点的...
GTK Gossip: GTree 與 GNode
uunubt的专栏
12-10 608
GTree 實現了平衡二元樹結構，在新增資料時會自動進行排序，並嘗試維持樹的高度與平衡，您可以利用Key來儲存資料至樹中，並利用Key來快速取得資料。<br /><br /> 直接來看個簡單的例子：<br />gtree_demo.c#include <glib.h><br /><br /> gint key_compare_func(gconstpointer a, gconstpointer b) {<br /> return g_strcmp0(a, b);<br /> }<
gStore 之 VS*-Tree
steppad
10-10 1219
gStore：gStore是由北京大学计算机所数据管理实验室研发面向RDF知识图谱的开源图数据库系统（通常称为Triple Store）。不同于传统基于关系数据库的知识图谱数据管理方法，gStore是一种原生基于图数据模型(Native Graph Model)的RDF数据管理系统，维持了原始RDF知识图谱的图结构；其数据模型是有标签、有向的多边图，每个顶点对应着一个主体或客体。我们将面向RDF的S
DTLib - 通用树结构的设计与实现（Tree、TreeNode、GTree、GTreeNode）
洋葱汪的博客
05-25 1172
目录 1、树的定义与操作 1、树的定义 2、树与结点抽象类的创建 2、通用树的存储结构与实现 1、通用树中结点的查找操作 2、通用树中结点的插入操作 3、通用树中结点的清除操作（工厂模式） 4、树中结点的删除操作 5、通用树中属性操作的实现 1、树中结点的数目 2、树的高度 3、树的度数 4、编程实验 3、树形结构的层次遍历 4、小结 1、树的定义与操作 1、树...
数据结构封装之 《SeqList顺序表》
BeiJiaan的博客
08-28 3996
数据结构封装之 《SeqList顺序表》 记录自己的学习过程，有兴趣的朋友可以加个好友，相互学习。
java如何快速封装树形结构数据
06-10
在 Java 中，可以使用递归算法来快速封装树形结构数据。以下是一个示例代码，展示如何使用递归算法来封装树形结构数据： ```java public class TreeUtils { /** * 将数据列表封装成树形结构 * @param dataList ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值