数据结构-树的存储结构

最新推荐文章于 2022-11-18 22:35:56 发布
最新推荐文章于 2022-11-18 22:35:56 发布
阅读量277 收藏
点赞数
分类专栏： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maweisky531/article/details/47709273
版权

树的存储结构：

利用链表组织树中的各个结点

链表中的前后关系不代表结点间的逻辑关系

结点的逻辑关系由 child 数据域描述

child 数据域保存其他结点的存储地址

树结点结构体

typedef struct _tag_GTreeNode GTreeNode;
struct _tag_GTreeNode
{
    GTreeData* data;
    GTreeNode* parent;
    LinkList* child;
};
链表结点结构体 

typedef struct _tag_LinkList
{
    LinkListNode header;
    int length;
} TLinkList;

树结点在链表中的位置不代表树的任何逻辑关系。

下面给出代码：

首先是线性表的头文件LinkList.h

#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
线性表的实现文件LinkList.c 

#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;
}
树定义头文件GTree.h 

#ifndef _TREE_H_
#define _TREE_H_

typedef void Tree;
typedef void TreeNode;

/* 创建树 */
Tree* Tree_Create();

/* 销毁已存在的树 */
void Tree_Destroy(Tree* tree);

/* 将已存在的树清空为空树 */
void Tree_Clear(Tree* tree);

/* 将结点node插入到tree中的pos位置处 */
int Tree_Insert(Tree* tree, TreeNode* node, int pos);

/* 将tree中pos位置的结点删除并返回 */
TreeNode* Tree_Delete(Tree* tree, int pos);

/* 将tree中pos位置的结点返回 */
TreeNode* Tree_Get(Tree* tree, int pos);

/* 返回tree的根结点 */
TreeNode* Tree_Root(Tree* tree);

/* 返回tree的高度 */
int Tree_Height(Tree* tree);

/* 返回树的结点数 */
int Tree_Count(Tree* tree);

/* 返回树的度数 */
int Tree_Degree(Tree* tree);

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

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);
    }
}
测试文件main.c 

#include <stdio.h>
#include "GTree.h"
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

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;
}
运行结果：



总结：

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

利用链表组织树结点

        能够便利的存取结点

        链表的维护具有一定复杂性


maweisky531
关注
专栏目录
Mysql存储过程生成树路径path
yyxlcl的博客
10-30 1790
因为项目里面的组织架构表没有保存组织路径，导致写sql查询不易查询上下级所属的数据，因此在组织架构表里面添加了path字段，用来保存该组织的路径path值，然后写存储过程对已有的数据进行了path值的生成执行的结果如下：这是不是就是你想要的结果？接下来解读该存储过程，让你根据自己的意愿去生成自己所想的路径值。
用存储过程显示树形结构
kexin520的专栏
01-07 852
昨天晚上一回家，我二姐就问了我这个问题，以前都没听说过，呵呵，见识真是少得可怜啊，今天有幸在网上查了查，因为以前1期的时候见过类似的，但是它那时有规律的，而这个没规律而后就查了查，用sql语句麻烦，用存储过程效率提高了，呵呵，于是自己动手建库，建表，写存储过程一试，出来了，use useDBgocreate   table   file(ID   int,   faID   i
C++数据结构day01-链式存储
qq_59841463的博客
11-18 365
于数据结构上来说，新手都是在定义结构体直接写进链式存储中，但对于企业项目我们要做到定义的结构体和数据结构的链式存储分离才算好。 现在我们来学习怎么去分离结构体和链式存储 这个的主要思想是我们将结构体定义到main.c中通过使用(LinkListNode*)(&t1)强转去调用函数，返回的值再利用强转(Teacher*)LinkList_Get(list, i)，得到值。
链表初始化typedef struct LNode{}LNode,*linklist的理解
qq_43244452的博客
09-23 1万+
typedef在C中叫做声明别名，就是说同种事物的另外一个称谓，而C的别名代表的是typedef后面定义的所有内容，别名会写在最后，所以，}后面的Lnode和*LinkListdou’shi都是struct Lnode的别名，使用别名的目的就是为了让结构体更方便于理解和控制，以后在使用的时候就很方便了，比如创建一个头指针，没有别名之前的写法是 struct Lnode *head = (struc...
数据结构封装之《LinkList单向链表》
BeiJiaan的博客
08-28 1092
数据结构封装之《LinkList线性链表》 本人健忘，留作记录。
漫话数据结构-树的存储结构.pptx
11-03
数据结构中的树是一种非常重要的非线性数据结构，它模拟了自然界中许多组织关系，如组织结构、文件系统等。本讲座主要介绍了三种常见的树的存储结构：双亲存储结构、孩子链式存储结构和孩子兄弟链式存储结构。 1. ...
数据结构--树与森林--思维导图.pdf
08-29
数据结构是计算机科学中的一门基础学科，它研究数据的逻辑结构、存储结构和访问方式。树和森林是数据结构中的两个重要概念，本篇文章将对其进行详细的讲解。 一、树的定义 树是一种特殊的图形结构，它由节点和边...
数据结构--二叉树--思维导图.pdf
08-29
二叉树是一种常见的数据结构，它是一种树形结构，每个节点最多有两个孩子节点，分别是左子树和右子树。二叉树可以用来存储大量数据，并且可以快速地查找、插入和删除数据。 二叉树的定义：二叉树是由节点组成的树形...
湖南大学-数据结构-期末试题【2016-2019】.zip
10-25
- 数组是一种线性数据结构，存储元素连续，通过索引访问。试题可能会考察数组的特性，如随机访问和修改，以及数组在排序、查找等操作中的应用。 - 链表不需连续存储，每个节点包含元素和指向下一个节点的指针。...
数据结构小练习-树 采用链式存储
最新发布
06-25
在本题中，我们关注的是树这一重要的数据结构，特别是链式存储的方式。链式存储是一种非连续存储方式，与数组不同，它允许每个节点根据需要占据内存的任意位置。 树是一种非线性数据结构，它由n（n>=1）个有限节点...
数据结构二叉树头文件BiTree.h
04-25
数据结构二叉树头文件BiTree.h
数据结构二叉树实验头文件
12-10
在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 一棵深度为k，且有2^k-1个结点的二叉树，称为满二叉树。这种树的特点是每一层上的结点数都是最大结点数。而在一棵二叉树中，除最后一层外，若其余层都是满的，并且或者最后一层是满的，或者是在右边缺少连续若干结点，则此二叉树为完全二叉树。具有n个结点的完全二叉树的深度为floor(log2n)+1。深度为k的完全二叉树，至少有2k-1个叶子结点，至多有2k-1个结点。
C_数据结构_链表的链式实现
weixin_33872660的博客
09-12 78
  传统的链表不能实现数据和链表的分离，一旦数据改变则链表就不能用了，就要重新开发。  如上说示：外层是Teacher,里面小的是node. #ifndef _MYLINKLIST_H_ #define _MYLINKLIST_H_ typedef void LinkList;//链表上下文,任意类型 typedef struct _tag_LinkListNode ...
线性表(List)---链式存储结构(单向链表)
StrugglingMice的博客
07-09 640
线性表(List)—链式存储结构存储设计与实现线性表链式结构的设计链式存储的基本介绍链式存储定义: 为了表示每个数据元素与其直接后继元素之间的逻辑关系，每个元素除了存储本身信息外，还需要存储指示其直接后继的信息。 表头结点： 链表中第一个结点，包含指向第一个数据匀速的指针，以及链表自身的一些信息。 数据结点： 链表中代表数据元素的结点，包含指向下一个数据元素的指针和信息。 尾结点
数据结构——普通树的定义与C++实现
lining0420的博客
07-26 2万+
实现了树的兄弟孩子表示法，插入新数据，查询某个数据，前序遍历，中序遍历，后序遍历。
数据结构——树、二叉树总结（一）
这个热点不太冷
07-25 2289
最近在看数据结构，准备跨考计算机专业，感觉一直看书很挺无趣的。感觉一周抽出一天写写总结，刷一刷OJ还是挺快乐的一件事情，感觉现在才做这些事情有点晚了，很多大佬已经很早之前就开始了，所以我只能站在大佬的肩膀上看世界了。 首先谈谈我总体对数据结构这们课的看法，我并没有上过这个课，听了几节课的视频，就听不下去了，可能是我不太喜欢别人讲课，再者就是这门课不太好讲吧。我第一本书看的是《大话数据结构...
数据结构之树的一些基本操作
believe_s的博客
08-01 2205
树是由根结点和若干颗子树构成的。树是由一个集合以及在该集合上定义的一种关系构成的。集合中的元素称为树的结点，所定义的关系称为父子关系。父子关系在树的结点之间建立了一个层次结构。在这种层次结构中有一个结点具有特殊的地位，这个结点称为该树的根结点，或称为树根。
数据结构之树的三种存储结构
热门推荐
Standxwf
04-28 5万+
说道存储结构,我们就会
数据结构中树的表示方法
Just The Way You Are
09-10 8844
树：非线性结构    在计算机中，就只有顺序存储和链式存储，但是对于树结构在计算机中的存储，当然可以天马行空能想到的方法很多，但是考虑到充分利用存储空间，这里说三种主要的表示方法 a)双亲表示法： 以双亲作为索引关键词的一种表示方法定义一个结构，对于每个节点，除了存储自身的信息，还存储着其双亲节点的位置 假设一组连续空间存储树的节点，同时在每个节点中，附设一个指示其双亲节点在数组中
数据结构-树与二叉树详解
"这篇资料是新东方在线考研计算机考点精讲课程讲义，涵盖了数据结构中的核心概念，如树与二叉树。" 在数据结构中，树是一种重要的非线性数据结构，它抽象地模拟了自然界中的许多组织关系。在【标题】提到的“树与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值