通用树的双亲表示法（代码演示））

最新推荐文章于 2023-01-05 23:52:28 发布
最新推荐文章于 2023-01-05 23:52:28 发布
阅读量788 收藏 5
点赞数
分类专栏： 数据结构和算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37968915/article/details/76513583
版权 
//通用树双亲表示法头文件
#ifndef __TREE_H__
#define __TREE_H__

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define FALSE 0
#define TRUE 1

struct _treenode;

typedef struct _childnode       //孩子链表内孩子结点
{
    struct _childnode *Next;
    struct _treenode *ChildNode; //指向孩子结点的指针
}CHILD_NODE;

typedef char TREE_DATA;
typedef struct _treenode         //树结点
{
    TREE_DATA data;
    struct _treenode *Parent;    //双亲结点
    struct _childnode *ChildList; //孩子结点链表
    struct _treenode *Next;
    int degree;                  //树结点的度
}TREE_NODE;

typedef struct _tree
{
    struct _treenode *head;      //带头结点，方便遍历
    int length;                  //树的总长度(不是高度)
}TREE;

//创建一个空树
extern TREE* CreateTree();
//在指定位置pos插入一个树结点
extern int InsertTreeNode(TREE* tree, TREE_DATA data, int pos);
//打印树
extern void Display(TREE* tree);
//删除指定位置pos的树结点
extern DeleteTreeeNode(TREE *tree, int pos, TREE_DATA* e);
//获得指定位置的树结点数据
extern int GetTreeNode(TREE* tree, int pos, TREE_DATA *e);
//清空一棵树
extern int ClearTree(TREE* tree);
//销毁一棵树
extern int DestoryTree(TREE* tree);
//获得根结点
extern TREE_NODE* GetTreeRoot(TREE* tree);
//获得树的总长度
extern int TreeLength(TREE* tree);
//获得树的高度
extern int TreeHeight(TREE* tree);
//获得树的度
extern int TreeDegree(TREE *tree);

#endif
//tree.c  包含了通用树的常用操作
#include "tree.h"

TREE* CreateTree()
{
    TREE* tree = (TREE*)malloc(sizeof(TREE));                    //创建一颗空树(包含头结点)
    if(tree == NULL)    
    {
        printf("create tree:malloc error!\n");
        return NULL;
    }
    tree->length = 0;                                            //初始长度为0
    tree->head = (TREE_NODE*)malloc(sizeof(TREE_NODE));          //带头结点的树
    if(tree->head == NULL)
    {
        printf("create tree head:malloc error!\n");
        free(tree);
        return NULL;
    }
    tree->head->degree = 0;                                      //初始化头结点
    tree->head->data = 0;
    tree->head->Next = NULL;
    tree->head->Parent = NULL;
    tree->head->ChildList = NULL;

    return tree;
}

int InsertTreeNode(TREE* tree, TREE_DATA data, int pos)          //在指定位置pos后面插入一个树结点
{
    if(tree == NULL || pos < 0 || pos > tree->length)
    {
        printf("insert tree node[1]:invalid input\n");
        return FALSE;
    }
    if(pos != 0 && tree->length == pos)//不能等于树的长度
    {
        printf("insert tree node[2]:invalid input\n");
        return FALSE;
    }

    TREE_NODE* node = (TREE_NODE*)malloc(sizeof(TREE_NODE));     //创建一个树结点
    if(node == NULL)
    {
        printf("insert tree node: node malloc error\n");
        return FALSE;
    }
    node->data = data;                                           //初始化数据内容
    node->Next = NULL;//指针域指向空

    node->ChildList = (CHILD_NODE*)malloc(sizeof(CHILD_NODE));   //创建该树结点的孩子链表头结点
    if(node->ChildList == NULL)
    {
        printf("insert tree node:childlist malloc error\n");
        free(node);
        return FALSE;
    }
    node->ChildList->Next = NULL;                                //初始化孩子链表头结点
    node->ChildList->ChildNode = NULL;

    int i = 0;
    TREE_NODE* _parent = tree->head->Next;                       //开始寻找双亲结点
    for (i = 0; i < pos; i++)
    {
        _parent = _parent->Next;//如果是根结点，则双亲为空
    }
    node->Parent = _parent;

    if(_parent != NULL)                                          //如果有双亲，则在其孩子链表中新增一个结点指向插入的结点
    {
        CHILD_NODE* child_node = (CHILD_NODE*)malloc(sizeof(CHILD_NODE));//新增的孩子链表结点
        if(child_node == NULL)
        {
            printf("insert tree node:child node malloc error!\n");
            free(node->ChildList);
            free(node);
            return FALSE;
        }
        child_node->Next = NULL;
        child_node->ChildNode = node;//让孩子链表结点指向需要插入的树结点

        CHILD_NODE* tmp = _parent->ChildList;                    //并且将其插入到双亲的孩子链表后面
        while (tmp->Next != NULL)
        {
            tmp = tmp->Next;
        }

        tmp->Next = child_node;
        _parent->degree++;                                       //别忘了双亲的度加一
    }
    TREE_NODE* temp = tree->head;                                //最后将该结点插入到树中
    while(temp->Next != NULL)
    {
        temp = temp->Next;
    }
    temp->Next = node;
    tree->length++;      //别忘了树的长度加一

    return TRUE;
}

void RDisplay(TREE_NODE* node, int gap)
{
    if(node == NULL)
    {
        printf("R display:no node\n");
        return ;
    }
    int i = 0;
    for(i = 0; i < gap; i++)
    {
        printf("%c", '-');//用来显示树的层次
    }
    printf("%c\n", node->data);

    CHILD_NODE* child = node->ChildList->Next;                   //当前结点的子结点
    while(child != NULL)
    {
        RDisplay(child->ChildNode, gap + 4);                     //打印孩子结点的孩子结点......如果是孩子结点，那么就得多打印4个'-'
        child = child->Next;
    }
}

void Display(TREE* tree)
{
    if(tree == NULL)
    {
        printf("display:invalid input\n");
        return ;
    }
    RDisplay(tree->head->Next, 0);                               //递归打印结点 这个参数0是用来初始化'-'的。
}

void RDelete(TREE *tree, TREE_NODE* node)
{
    if(tree == NULL || node == NULL)
    {
        printf("R delete:unexpected error\n");
        return ;
    }
    TREE_NODE* tmp = tree->head;                                 //1.将需要删除的树结点移出来，树长度减一
    while(tmp->Next != NULL)
    {
        if(tmp->Next == node)
        {
            tmp->Next = node->Next;//也就是这一步
            tree->length--;
            break;
        }
        tmp = tmp->Next;
    }

    TREE_NODE* parent = node->Parent;                            //2.删除双亲结点孩子链表中指向该结点的结点
    if(parent != NULL)
    {
        CHILD_NODE* temp = parent->ChildList;
        while(temp->Next != NULL)
        {
            if(temp->Next->ChildNode == node)
            {
                CHILD_NODE* p = temp->Next;
                temp->Next = p->Next;
                free(p);
                parent->degree--;                                //别忘了双亲的度减一
                break;
            }
            temp = temp->Next;
        }
    }

    CHILD_NODE* child = node->ChildList->Next;                   //3.删除该结点的孩子结点
    while (child != NULL)
    {
        CHILD_NODE* pchild = child->Next;//这边保存child的next域是为了防止程序长时间运行后，该域被意外修改导致程序崩溃
        RDelete(tree, child->ChildNode);                         //4.每个孩子结点的孩子链表处理并且删除其孩子结点
        child  = pchild;
    }

    free (node->ChildList);   //别忘了释放两个空间
    free (node);
}

int DeleteTreeNode(TREE* tree, int pos, TREE_DATA *e)  //删除指定位置pos的树结点
{
    if(tree == NULL || pos < 0 || pos > tree->length)
    {
        printf("delete tree node:input invalid\n");
        return FALSE;
    }
    if(pos != 0 && pos == tree->length)
    {
        printf("delete tree node:input invalid\n");
        return FALSE;
    }
    int i = 0;
    TREE_NODE* node = tree->head->Next;                          //树中第一个结点
    for (i = 0; i < pos; i++)
    {
        node = node->Next;                                       //遍历到需要删除的结点位置
    }
    *e = node->data;                                             //保存所需删除的结点的数据
    RDelete(tree, node);                                         //递归删除

    return TRUE;
}

int GetTreeNode(TREE* tree, int pos, TREE_DATA *e)
{
    if(tree == NULL || pos < 0 || pos > tree->length)
    {
        printf("get tree node:input invalid\n");
        return FALSE;
    }
    if(pos != 0 && pos == tree->length)
    {
        printf("get tree node:input invalid\n");
        return FALSE;
    }
    int i = 0;
    //遍历到该结点直接返回即可
    TREE_NODE* tmp = tree->head->Next;
    for(i = 0; i < pos; i++)
    {
        tmp = tmp->Next;
    }
    *e = tmp->data;

    return TRUE;
}

int ClearTree(TREE* tree)
{
    if(tree == NULL)
    {
        printf("clear tree:no tree\n");
        return FALSE;
    }
    TREE_DATA e;

        return DeleteTreeNode(tree, 0, &e);//其实就是删除根结点
}

int DestoryTree(TREE *tree)
{
    if(tree == NULL)
    {
        printf("destory tree:no tree\n");
        return FALSE;
    }

    ClearTree(tree);

    free(tree->head);  //清空之后再把刚开始分配的树和头结点释放掉
    free(tree);

    return TRUE;
}

TREE_NODE* GetTreeRoot(TREE* tree)
{
    if(tree == NULL)
    {
        printf("get tree root:no tree\n");
        return FALSE;
    }

    return tree->head->Next;
}

int TreeLength(TREE* tree)
{
    if(tree == NULL)
    {
        printf("get tree length:no tree\n");
        return FALSE;
    }

    return tree->length;
}

int RHeight(TREE_NODE* node)
{
    if(node == NULL)
    {
        printf("r height:no tree head\n");
        return FALSE;
    }
    int SubHeight = 0;
    int max = 0;
    CHILD_NODE* child = node->ChildList->Next;//第一个孩子结点
    while(child != NULL)  //遍历孩子链表
    {
        SubHeight = RHeight(child->ChildNode); //向下递归找最深的叶子结点，最后一级一级返回求出max
        if(SubHeight > max)
        {
            max = SubHeight;
        }
        child = child->Next;
    }

    return max + 1;  //由于根结点没算上所以返回max+1
}

int TreeHeight(TREE* tree)
{
    if(tree == NULL)
    {
        printf("get tree height:no tree\n");
        return FALSE;
    }
    int height = RHeight(tree->head->Next);//从第一个结点开始向下递归深入求深度

    return height;
}

int RDegree(TREE_NODE* node)
{
    if(node == NULL)
    {
        printf("get tree degree:no tree head\n");
        return FALSE;
    }
    int SubDegree = 0;
    int max = node->degree;  //假设当前结点度最大
    CHILD_NODE* child = node->ChildList->Next;
    while(child != NULL)
    {
        SubDegree = RDegree(child->ChildNode);向下递归找最大度
        if(SubDegree > max)
        {
            max = SubDegree;
        }
        child = child->Next;
    }

    return max;
}

int TreeDegree(TREE* tree)
{
    if(tree == NULL)
    {
        printf("get tree degree:no tree\n");
        return FALSE;
    }
    int degree = RDegree(tree->head->Next);

    return degree;
}

//main.c 基本测试
#include "tree.h"

int main()
{
    TREE* tree = CreateTree();
    if(tree == NULL)
    {
        return -1;
    }
    InsertTreeNode(tree, 'A', 0);
    InsertTreeNode(tree, 'B', 0);
    InsertTreeNode(tree, 'C', 0);
    InsertTreeNode(tree, 'D', 0);
    InsertTreeNode(tree, 'E', 1);
    InsertTreeNode(tree, 'F', 1);
    InsertTreeNode(tree, 'G', 3);
    InsertTreeNode(tree, 'H', 3);
    InsertTreeNode(tree, 'I', 3);
    InsertTreeNode(tree, 'J', 8);

    Display(tree);

    printf("删除结点D\n");
    TREE_DATA e;
    DeleteTreeNode(tree, 3, &e);
    Display(tree);

    printf("获取结点F的值\n");
    TREE_DATA e1;
    GetTreeNode(tree, 4, &e1);
    printf("F data is %c\n", e1);

    printf("获取树的高度\n");
    int height = TreeHeight(tree);
    printf("树的高度为 %d\n", height);

    printf("获取树的度\n");
    int degree = TreeDegree(tree);
    printf("树的度为 %d\n", degree);

    return 0;
}

这是程序的运行结果

追随圣光吧
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树的孩子兄弟表示法代码.rar
05-21
树的孩子兄弟表示法代码，使用C++编写，调试通过，初学者下载，很好的资料，专门给刚入门数据结构的同学（缺少查找双亲的代码）
C/C++实现树的双亲表示法（树的顺序存储）
weixin_44915226的博客
07-02 798
图示 存储结构：   代码 #include <iostream> #include <stdio.h> #define MAX_TREE_SIZE 100 using namespace std; typedef char ElemType; typedef struct{ ElemType data; int parent; }PTNode; typedef struct{ PTNode nodes[20]; int n; }PTree; int
树-双亲表示法（含全部代码）
关注网络安全、云原生安全
02-25 7920
基本操作函数： InitTree(Tree &amp;T) 参数T，树根节点 作用：初始化树，先序递归创建 InsertNode(Tree &amp;T, TElemType node) 插入树的结点 参数：树T,结点node 作用：在双亲数组中插入结点，增加树的结点值 InsertParent(Tree &amp;T, TElemType node1, TElemType node2)//插入...
树的双亲表示法&孩子表示法代码实现
Miss Z的博客
09-06 5787
孩子表示法 孩子链存储结构的类型声明 typedef struct { int child; //孩子结点在数组中的位置 struct CTNode *next; //下一个孩子 }CTNode; typedef struct { ElemType data; struct CTNode *firstChild; //第一个孩子 }CTBox; typedef struct { CTBox nodes[MAX_TREE_SIZE]; int n,r; //结点数和根的位置 }CTree;
树的存储结构-双亲表示法-代码
MZCY的博客
05-09 4547
树的存储结构：双亲表示法
（数据结构）树的双亲表示法
weixin_51927215的博客
03-30 5965
树的双亲表示法 此前写过二叉树的顺序存储和链式存储，此篇文章将介绍普通树是如何存储的... 通常，存储具有普通树结构数据的方法有 3 种： 双亲表示法 孩子表示法 孩子兄弟表示法 而本篇文章将优先介绍双亲表示法！！！ 双亲表示法采用顺序表（数组）存储普通树，其实现的核心思想是：顺序存储各个节点的同时，给各节点附加一个记录其父节点位置的变量 ​ 图 1 普通树 双亲表示法存储图 1 中普通树，其存储状态如图 2 所示 ： 图 2 双亲表示法存储普通树示意图 注意！！！根节点没有父节点
C语言数据结构树的双亲表示法实例详解
08-30
主要介绍了C语言数据结构树的双亲表示法实例详解的相关资料,需要的朋友可以参考下
树的双亲表示法的前序遍历
04-27
树的前序（深度优先）遍历算法。非递归算法，通过设置栈来完成。
树与森林（C++实现）
qq_39559641的博客
04-07 7177
一、实验要求 (1)按先序、后序、层次遍历森林。 (2)求森林的高度。 (3)求森林结点总数。 (4)求森林叶子结点数。 (5)求森林的度。 (6)先序输出结点值及其层次号。 (7)输出广义表表示的树。 二、数据结构设计 typedef char elementType; typedef struct csNode { element...
树的存储(双亲表示法)
weixin_42295110的博客
08-04 3161
此种方式找父节点好找,但是找子结点需要遍历整个数组。 删除某一个结点时:(思路) 1.该结点没有孩子,直接删除即可。 2.该结点有孩子,需要递归将孩子结点删除,然后再删除该结点。 删除时的小细节： 1.每删除一个元素时,将数组中的最后一个元素前移,节省存储空间,遍历数组时方便,遍历的元素少,但是存在问题。（F结点有子结点,F的子结点在未删除的情况,F结点进行了移动,导致F结点的下标发生了变化,继而导致 GHK与F结点失联。） 2.删...
常用数据结构之树的双亲_孩子_孩子兄弟表示法
gaobing1993的博客
10-03 7362
1.树的双亲表示法 前面我们聊得都是二叉树，今天我们来讨论一下如何去表示一棵普通的树。常用的表示方法有三种：双亲表示法、孩子表示法和孩子兄弟表示法。我们首先来聊一下双亲表示法，顾名思义，双亲表示法就是在每一个节点中，存储其父节点的下标。这样就可以将树中各节点的结构关系表示出来，也可以快速的对父节点进行访问。 如下图所示我们将一棵普通的树，用图二中的列表形式进行存储。 具体的python实现代码，如下所示(个人手写，不喜勿怪)： #-*- coding:utf-8 -*- class Node:
Python数据结构与算法之树
qq_63215420的博客
01-05 1386
树是一种非常重要的非线性结构，它在计算机领域的应用十分广泛，如在编译程序或数据库程序中。树形结构具有分支性（分支性是由于一个或多个或多个结点存在两个或两个以上直接后继节点）和层次性（层次性是由分支产生并呈现出来的）两大特点。
树的双亲表示法可执行代码（创建树，层次遍历，求深度）
iteye_8029的博客
12-31 447
import java.util.LinkedList; import java.util.Queue; import java.util.Scanner; //双亲表示法创建 public class PTree&lt;AnyType&gt;{ PTNode nodes[]=new PTNode[15]; int n; //结点在数组中的位置 PTNod...
树的存储_ 双亲表示法 及 双亲孩子表示法
热门推荐
惊鸿一博
05-23 2万+
1.概念 树状图是一种数据结构，它是由n（n>=1）个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：每个节点有零个或多个子节点；没有父节点的节点称为根节点；每一个非根节点有且只有一个父节点；除了根节点外，每个子节点可以分为多个不相交的子树。 节点的度(degree)：一个节点含有的子树的个数称为该...
树的双亲表示法
myblog
12-09 2万+
由于树中的每个结点都有唯一的一个双亲结点，所以可用一组连续的存储空间（一维数组）存储树中的各个结点，数组中的一个元素表示树中的一个结点，每个结点含两个域，数据域存放结点本身信息，双亲域指示本结点的双亲结点在数组中位置。C语言代码实现：#include<stdio.h> #include<stdlib.h> #define MAX_SIZE 20 typedef char ElemType; type
C语言数据结构——树的双亲表示法
sunshine_rebrith的博客
06-03 6765
1、树的双亲表示法： 2、/* bo6-4.c 树的双亲表存储(存储结构由c6-4.h定义)的基本操作(14个) */ Status InitTree(PTree *T) { /* 操作结果: 构造空树T */ (*T).n=0; return OK; } void DestroyTree() { /* 由于PTree是定长类型,无法销毁 */ } typedef stru
数据结构：树的存储——双亲表示法
憧憬，思考，奋斗，飞翔
05-08 4466
/*********************************************** 程序：树的存储-----双亲表示法 完成者：小单 完成时间:2013年5月20日 ***********************************************/ #include #define MAX_TREE_SIZE 100 #define OK 1 #
树的孩子表示法代码
最新发布
05-24
下面是一份示例代码，实现了树的孩子表示法： ```python class TreeNode: def __init__(self, value): self.value = value self.children = [] def add_child(self, child_node): self.children.append(child...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值