《数据结构》-树(双亲表示法)

最新推荐文章于 2024-04-15 08:23:55 发布
最新推荐文章于 2024-04-15 08:23:55 发布
阅读量1.2k 收藏 4
点赞数 2
分类专栏： 数据结构 文章标签： 树 双亲表示法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tyustli/article/details/119086499
版权

双亲表示法
孩子链表表示法
孩子兄弟表示法

树的存储结构

请添加图片描述

双亲表示法

请添加图片描述
对应的树为

请添加图片描述

特点

找双亲容易，找孩子难

C 语言的类型描述

#define MAX_TREE_SIZE 100
/* 结点结构 */
struct PTNode
{
    TElemType data;
    int parent; // 双亲位置域
};
/* 树结构 */
struct PTree
{
    struct PTNode nodes[MAX_TREE_SIZE];
    int r; // 根结点的位置
    int n; // 结点个数
};

源码实现

main.c

/*
 * Change Logs:
 * Date           Author       Notes
 * 2021-07-20     tyustli      first version
 */

#include "tree.h"

void visitT(TElemType e)
{
    printf("%d ", e);
}

int main(int argc, char *argv[])
{
    printf("this bitree\r\n");
    int i;
    struct PTree T, p;
    TElemType e, e1;
    InitTree(&T);
    printf("构造空树后,树空否? %d(1:是 0:否) 树根为%c 树的深度为%d\n", TreeEmpty(T), Root(T), TreeDepth(T));
    CreateTree(&T);
    printf("构造树T后,树空否? %d(1:是 0:否) 树根为%c 树的深度为%d\n", TreeEmpty(T), Root(T), TreeDepth(T));
    printf("层序遍历树T:\n");
    TraverseTree(T, visitT);
    printf("请输入待修改的结点的值 新值: ");
    scanf("%c%*c%c%*c", &e, &e1);
    Assign(&T, e, e1);
    printf("层序遍历修改后的树T:\n");
    TraverseTree(T, visitT);
    printf("%c的双亲是%c,长子是%c,下一个兄弟是%c\n", e1, Parent(T, e1), LeftChild(T, e1), RightSibling(T, e1));
    printf("建立树p:\n");
    InitTree(&p);
    CreateTree(&p);
    printf("层序遍历树p:\n");
    TraverseTree(p, visitT);
    printf("将树p插到树T中，请输入T中p的双亲结点 子树序号: ");
    scanf("%c%d%*c", &e, &i);
    InsertChild(&T, e, i, p);
    Print(T);
    printf("删除树T中结点e的第i棵子树，请输入e i: ");
    scanf("%c%d", &e, &i);
    DeleteChild(&T, e, i);
    Print(T);
}

/***************** end of file ******************/

tree.c

#include "tree.h"

// 树的双亲表存储的基本操作
#define ClearTree InitTree   // 二者操作相同
#define DestroyTree InitTree // 二者操作相同

TElemType Nil = 0; // 设整型以0为空

void InitTree(struct PTree *T)
{ // 操作结果：构造空树T
    (*T).n = 0;
}

#if 1
typedef struct
{
    int num;
    TElemType name;
} QElemType; // 定义队列元素类型

typedef struct QNode
{
    QElemType data;     /* 数据域 */
    struct QNode *next; /* 指针域 */
} QNode, *QueuePtr;

typedef struct LinkQueue
{
    QueuePtr front; // 队头指针
    QueuePtr rear;  // 队尾指针
} LinkQueue;

void InitQueue(LinkQueue *Q);
void DestroyQueue(LinkQueue *Q);
void ClearQueue(LinkQueue *Q);
Status QueueEmpty(LinkQueue Q);
int QueueLength(LinkQueue Q);
Status GetHead(LinkQueue Q, QElemType *e);
void EnQueue(LinkQueue *Q, QElemType e);
Status DeQueue(LinkQueue *Q, QElemType *e);
void QueueTraverse(LinkQueue Q, void (*vi)(QElemType));
void print(QElemType i);
void InitQueue(LinkQueue *Q)
{
    Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));

    if (Q->front == NULL)
        exit(-1);
    Q->front->next = NULL;
}

void DestroyQueue(LinkQueue *Q)
{
    while (Q->front)
    {
        Q->rear = Q->front->next;
        free(Q->front);
        Q->front = Q->rear;
    }
}

void ClearQueue(LinkQueue *Q)
{
    QueuePtr p, q;
    Q->rear = Q->front;
    p = Q->front->next;
    Q->front->next = NULL;
    while (p)
    {
        q = p;
        p = p->next;
        free(q);
    }
}
Status QueueEmpty(LinkQueue Q)
{
    if (Q.front->next == NULL)
        return TRUE;
    else
        return FALSE;
}
int QueueLength(LinkQueue Q)
{
    int i = 0;
    QueuePtr p;
    p = Q.front;
    while (Q.rear != p)
    {
        i++;
        p = p->next;
    }
    return i;
}
Status GetHead(LinkQueue Q, QElemType *e)
{
    QueuePtr p;
    if (Q.front == Q.rear)
        return ERROR;
    p = Q.front->next;
    *e = p->data;

    return OK;
}
void EnQueue(LinkQueue *Q, QElemType e)
{
    QueuePtr p;
    if (!(p = (QueuePtr)malloc(sizeof(QNode))))
        exit(-1);
    p->data = e;
    p->next = NULL;
    Q->rear->next = p;
    Q->rear = p;
}
Status DeQueue(LinkQueue *Q, QElemType *e)
{
    QueuePtr p;
    if (Q->front == Q->rear)
        return ERROR;
    p = Q->front->next;
    *e = p->data;
    Q->front->next = p->next;
    if (Q->rear == p)
        Q->rear = Q->front;
    free(p);

    return OK;
}
void QueueTraverse(LinkQueue Q, void (*vi)(QElemType))
{
    QueuePtr p;
    p = Q.front->next;
    while (p)
    {
        vi(p->data);
        p = p->next;
    }
    printf("\n");
}
void print(QElemType i)
{
    // printf("%s ", i);
}
#endif

// 操作结果：构造树T
void CreateTree(struct PTree *T)
{
    LinkQueue q;
    QElemType p, qq;
    int i = 1, j, l;
    char c[MAX_TREE_SIZE]; // 临时存放孩子结点数组

    InitQueue(&q); // 初始化队列
    printf("请输入根结点(字符型,空格为空): ");
    scanf("%c ", &(T->nodes[0].data)); // 根结点序号为0，%*c吃掉回车符
    if (T->nodes[0].data != Nil)       // 非空树
    {
        T->nodes[0].parent = -1; // 根结点无双亲
        qq.name = T->nodes[0].data;
        qq.num = 0;
        EnQueue(&q, qq);                            // 入队此结点
        while (i < MAX_TREE_SIZE && !QueueEmpty(q)) // 数组未满且队不空
        {
            DeQueue(&q, &qq); // 出队一个结点
            printf("请按长幼顺序输入结点%d的所有孩子: ", qq.name);
            scanf("%c ", c);
            l = strlen(c);
            for (j = 0; j < l; j++)
            {
                T->nodes[i].data = c[j];
                T->nodes[i].parent = qq.num;
                p.name = c[j];
                p.num = i;
                EnQueue(&q, p); // 入队此结点
                i++;
            }
        }
        if (i > MAX_TREE_SIZE)
        {
            printf("结点数超过数组容量\n");
            exit(-1);
        }
        T->n = i;
    }
    else
    {
        T->n = 0;
    }
}

// 初始条件：树T存在。
// 操作结果：若T为空树，则返回TRUE，否则返回FALSE
Status TreeEmpty(struct PTree T)
{
    if (T.n)
        return FALSE;
    else
        return TRUE;
}

// 初始条件：树T存在。
// 操作结果：返回T的深度
int TreeDepth(struct PTree T)
{ 
    int k, m, def, max = 0;
    for (k = 0; k < T.n; ++k)
    {
        def = 1; // 初始化本结点的深度
        m = T.nodes[k].parent;
        while (m != -1)
        {
            m = T.nodes[m].parent;
            def++;
        }
        if (max < def)
            max = def;
    }
    return max; // 最大深度
}

// 初始条件：树T存在。
// 操作结果：返回T的根
TElemType Root(struct PTree T)
{
    int i;
    for (i = 0; i < T.n; i++)
        if (T.nodes[i].parent < 0)
            return T.nodes[i].data;
    return Nil;
}

// 初始条件：树T存在，i是树T中结点的序号。
// 操作结果：返回第i个结点的值
TElemType Value(struct PTree T, int i)
{
    if (i < T.n)
        return T.nodes[i].data;
    else
        return Nil;
}

// 初始条件：树T存在，cur_e是树T中结点的值。
// 操作结果：改cur_e为value
Status Assign(struct PTree *T, TElemType cur_e, TElemType value)
{
    int j;
    for (j = 0; j < T->n; j++)
    {
        if (T->nodes[j].data == cur_e)
        {
            T->nodes[j].data = value;
            return OK;
        }
    }
    return ERROR;
}

// 初始条件：树T存在，cur_e是T中某个结点
// 操作结果：若cur_e是T的非根结点，则返回它的双亲，否则函数值为＂空＂
TElemType Parent(struct PTree T, TElemType cur_e)
{
    int j;
    for (j = 1; j < T.n; j++) // 根结点序号为0
        if (T.nodes[j].data == cur_e)
            return T.nodes[T.nodes[j].parent].data;
    return Nil;
}

// 初始条件：树T存在，cur_e是T中某个结点
// 操作结果：若cur_e是T的非叶子结点，则返回它的最左孩子，否则返回＂空＂
TElemType LeftChild(struct PTree T, TElemType cur_e)
{
    int i, j;
    for (i = 0; i < T.n; i++)
        if (T.nodes[i].data == cur_e) // 找到cur_e，其序号为i
            break;
    for (j = i + 1; j < T.n; j++)   // 根据树的构造函数，孩子的序号＞其双亲的序号
        if (T.nodes[j].parent == i) // 根据树的构造函数，最左孩子(长子)的序号＜其它孩子的序号
            return T.nodes[j].data;
    return Nil;
}

// 初始条件：树T存在，cur_e是T中某个结点
// 操作结果：若cur_e有右(下一个)兄弟，则返回它的右兄弟，否则返回＂空＂
TElemType RightSibling(struct PTree T, TElemType cur_e)
{
    int i;
    for (i = 0; i < T.n; i++)
        if (T.nodes[i].data == cur_e) // 找到cur_e，其序号为i
            break;
    if (T.nodes[i + 1].parent == T.nodes[i].parent)
        // 根据树的构造函数，若cur_e有右兄弟的话则右兄弟紧接其后
        return T.nodes[i + 1].data;
    return Nil;
}

// 输出树T
void Print(struct PTree T)
{
    int i;
    printf("结点个数=%d\n", T.n);
    printf(" 结点 双亲\n");
    for (i = 0; i < T.n; i++)
    {
        printf("%c", Value(T, i));                     // 结点
        if (T.nodes[i].parent >= 0)                        // 有双亲
            printf("%c", Value(T, T.nodes[i].parent)); // 双亲
        printf("\n");
    }
}

// 初始条件：树T存在，p是T中某个结点，1≤i≤p所指结点的度+1，非空树c与T不相交
// 操作结果：插入c为T中p结点的第i棵子树
Status InsertChild(struct PTree *T, TElemType p, int i, struct PTree c)
{
    int j, k, l, f = 1, n = 0; // 设交换标志f的初值为1，p的孩子数n的初值为0
    struct PTNode t;
    if (!TreeEmpty(*T)) // T不空
    {
        for (j = 0; j < (*T).n; j++)     // 在T中找p的序号
            if ((*T).nodes[j].data == p) // p的序号为j
                break;
        l = j + 1; // 如果c是p的第1棵子树，则插在j+1处
        if (i > 1) // c不是p的第1棵子树
        {
            for (k = j + 1; k < (*T).n; k++)   // 从j+1开始找p的前i-1个孩子
                if ((*T).nodes[k].parent == j) // 当前结点是p的孩子
                {
                    n++;            // 孩子数加1
                    if (n == i - 1) // 找到p的第i-1个孩子，其序号为k1
                        break;
                }
            l = k + 1;                        // c插在k+1处
        }                                     // p的序号为j，c插在l处
        if (l < (*T).n)                       // 插入点l不在最后
            for (k = (*T).n - 1; k >= l; k--) // 依次将序号l以后的结点向后移c.n个位置
            {
                (*T).nodes[k + c.n] = (*T).nodes[k];
                if ((*T).nodes[k].parent >= l)
                    (*T).nodes[k + c.n].parent += c.n;
            }
        for (k = 0; k < c.n; k++)
        {
            (*T).nodes[l + k].data = c.nodes[k].data; // 依次将树c的所有结点插于此处
            (*T).nodes[l + k].parent = c.nodes[k].parent + l;
        }
        (*T).nodes[l].parent = j; // 树c的根结点的双亲为p
        (*T).n += c.n;            // 树(*T)的结点数加c.n个
        while (f)
        {          // 从插入点之后，将结点仍按层序排列
            f = 0; // 交换标志置0
            for (j = l; j < (*T).n - 1; j++)
                if ((*T).nodes[j].parent > (*T).nodes[j + 1].parent)
                { // 如果结点j的双亲排在结点j+1的双亲之后(树没有按层序排列)，交换两结点
                    t = (*T).nodes[j];
                    (*T).nodes[j] = (*T).nodes[j + 1];
                    (*T).nodes[j + 1] = t;
                    f = 1;                       // 交换标志置1
                    for (k = j; k < (*T).n; k++) // 改变双亲序号
                        if ((*T).nodes[k].parent == j)
                            (*T).nodes[k].parent++; // 双亲序号改为j+1
                        else if ((*T).nodes[k].parent == j + 1)
                            (*T).nodes[k].parent--; // 双亲序号改为j
                }
        }
        return OK;
    }
    else // 树T不存在
        return ERROR;
}

Status deleted[MAX_TREE_SIZE + 1]; // 删除标志数组(全局量)
void DeleteChild(struct PTree *T, TElemType p, int i)
{ // 初始条件：树T存在，p是T中某个结点，1≤i≤p所指结点的度
    // 操作结果：删除T中结点p的第i棵子树
    int j, k, n = 0;
    LinkQueue q;
    QElemType pq, qq;
    for (j = 0; j <= (*T).n; j++)
        deleted[j] = 0; // 置初值为0(不删除标记)
    pq.name = 'a';      // 此成员不用
    InitQueue(&q);       // 初始化队列
    for (j = 0; j < (*T).n; j++)
        if ((*T).nodes[j].data == p)
            break; // j为结点p的序号
    for (k = j + 1; k < (*T).n; k++)
    {
        if ((*T).nodes[k].parent == j)
            n++;
        if (n == i)
            break; // k为p的第i棵子树结点的序号
    }
    if (k < (*T).n) // p的第i棵子树结点存在
    {
        n = 0;
        pq.num = k;
        deleted[k] = 1; // 置删除标记
        n++;
        EnQueue(&q, pq);
        while (!QueueEmpty(q))
        {
            DeQueue(&q, &qq);
            for (j = qq.num + 1; j < (*T).n; j++)
                if ((*T).nodes[j].parent == qq.num)
                {
                    pq.num = j;
                    deleted[j] = 1; // 置删除标记
                    n++;
                    EnQueue(&q, pq);
                }
        }
        for (j = 0; j < (*T).n; j++)
            if (deleted[j] == 1)
            {
                for (k = j + 1; k <= (*T).n; k++)
                {
                    deleted[k - 1] = deleted[k];
                    (*T).nodes[k - 1] = (*T).nodes[k];
                    if ((*T).nodes[k].parent > j)
                        (*T).nodes[k - 1].parent--;
                }
                j--;
            }
        (*T).n -= n; // n为待删除结点数
    }
}

void TraverseTree(struct PTree T, void (*Visit)(TElemType))
{ // 初始条件：二叉树T存在，Visit是对结点操作的应用函数
    // 操作结果：层序遍历树T，对每个结点调用函数Visit一次且仅一次
    int i;
    for (i = 0; i < T.n; i++)
        Visit(T.nodes[i].data);
    printf("\n");
}

/***************** end of file ******************/

tree.h

/*
 * Change Logs:
 * Date           Author       Notes
 * 2021-07-20     tyustli      first version
 */

#include <string.h>
#include <ctype.h>
#include <malloc.h> // malloc()等
#include <limits.h> // INT_MAX等
#include <stdio.h>  // EOF(=^Z或F6),NULL
#include <stdlib.h> // atoi()
#include <math.h>   // floor(),ceil(),abs()

// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
// #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行
typedef int Status;  // Status是函数的类型,其值是函数结果状态代码，如OK等
typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSE

typedef char TElemType;

#define MAX_TREE_SIZE 100
/* 结点结构 */
struct PTNode
{
    TElemType data;
    int parent; // 双亲位置域
};
/* 树结构 */
struct PTree
{
    struct PTNode nodes[MAX_TREE_SIZE];
    int r; // 根结点的位置
    int n; // 结点个数
};

void InitTree(struct PTree *T);
void ClearTree(struct PTree *T);
void DestroyTree(struct PTree *T);
void CreateTree(struct PTree *T);
Status TreeEmpty(struct PTree T);
int TreeDepth(struct PTree T);
TElemType Root(struct PTree T);
TElemType Value(struct PTree T, int i);
Status Assign(struct PTree *T, TElemType cur_e, TElemType value);
TElemType Parent(struct PTree T, TElemType cur_e);
TElemType LeftChild(struct PTree T, TElemType cur_e);
TElemType RightSibling(struct PTree T, TElemType cur_e);
void Print(struct PTree T);
Status InsertChild(struct PTree *T, TElemType p, int i, struct PTree c);
void DeleteChild(struct PTree *T, TElemType p, int i);
void TraverseTree(struct PTree T, void (*Visit)(TElemType));


/***************** end of file ******************/

makefile

objects  = main.o tree.o
obj: $(objects)
	cc -o obj $(objects) -lm

main.o : tree.h
tree.o : tree.h

.PHONY : clean
clean :
	-rm obj $(objects)
tyustli
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
常用数据结构之树的双亲_孩子_孩子兄弟表示法
gaobing1993的博客
10-03 7544
1.树的双亲表示法 前面我们聊得都是二叉树，今天我们来讨论一下如何去表示一棵普通的树。常用的表示方法有三种：双亲表示法、孩子表示法和孩子兄弟表示法。我们首先来聊一下双亲表示法，顾名思义，双亲表示法就是在每一个节点中，存储其父节点的下标。这样就可以将树中各节点的结构关系表示出来，也可以快速的对父节点进行访问。 如下图所示我们将一棵普通的树，用图二中的列表形式进行存储。 具体的python实现代码，如下所示(个人手写，不喜勿怪)： #-*- coding:utf-8 -*- class Node:
数据结构 - 树的两种生成方式：双亲表示法和孩子表示法
陈杉菜
10-28 6155
上个星期，周老师跳过队列讲了树= = 所以我们先写数据结构中关于树的一小部分知识 先康康树的样子： 随意介绍一下 ： A 就是这个树的根节点，GHIJ是这个树的叶子节点 然后 这个图就不是树，它是什么呢 回答：森林（只有两颗树的森林） 然后介绍了和树有关的相关概念 树 ： 树是由结点或顶点和边组成的(可能是非线性的)且不存在着任何环的一种数据结构。没有结点的树称为空(null或empty)树。...
5.3、树的双亲表示法
最新发布
融码一生：专注 Python、C/C++、Linux、机器学习 & 深度学习、NLP、算法领域分享
04-15 459
前面讲了二叉树的顺序存储和链式存储，本节来学习如何存储具有普通树结构的数据。
（数据结构）树的双亲表示法
weixin_51927215的博客
03-30 6338
树的双亲表示法 此前写过二叉树的顺序存储和链式存储，此篇文章将介绍普通树是如何存储的... 通常，存储具有普通树结构数据的方法有 3 种： 双亲表示法 孩子表示法 孩子兄弟表示法 而本篇文章将优先介绍双亲表示法！！！ 双亲表示法采用顺序表（数组）存储普通树，其实现的核心思想是：顺序存储各个节点的同时，给各节点附加一个记录其父节点位置的变量 ​ 图 1 普通树 双亲表示法存储图 1 中普通树，其存储状态如图 2 所示 ： 图 2 双亲表示法存储普通树示意图 注意！！！根节点没有父节点
数据结构：树的存储——双亲表示法
憧憬，思考，奋斗，飞翔
05-08 4483
/*********************************************** 程序：树的存储-----双亲表示法 完成者：小单 完成时间:2013年5月20日 ***********************************************/ #include #define MAX_TREE_SIZE 100 #define OK 1 #
数据结构——树的双亲表示法
minyuanxiani的专栏
09-04 3894
#include using namespace std; #define MAX_TREE_SIZE 100 typedef struct //节点结构 { char data; int parent; //双亲位置域 }PTNode; typedef struct //树结构 { PTNode node[
C语言数据结构树的双亲表示法实例详解
08-30
C语言数据结构树的双亲表示法实例详解 本资源主要介绍了C语言数据结构树的双亲表示法实例详解的相关资料，涵盖了树的双亲表示法的定义、基本操作、存储结构、队列操作等多方面的知识点。 树的双亲表示法 树的双亲...
数据结构-树和二叉树-PPT
02-04
数据结构-树和二叉树-PPT 树是一种非常重要的非线性数据结构，它用于描述数据元素之间的层次关系。在客观世界中，树形结构广泛存在，如人类社会的族谱和各种社会组织机构都可用树来形象表示。 树的定义：树是一棵n...
树的双亲表示法的前序遍历
04-27
总之，理解和掌握树的双亲表示法以及非递归前序遍历算法，对于进行树型数据结构的操作和分析是非常关键的。这些概念和技巧在软件开发、数据库设计、编译原理等多个领域都有广泛应用。通过实践和练习，可以进一步巩固...
树的孩子兄弟表示法代码.rar
05-21
这种表示法对初学者来说是很有价值的学习材料，特别是对于正在学习数据结构入门阶段的同学。 孩子兄弟表示法是一种树的链式存储结构，它的每个节点包含两个指针：一个用于指向其第一个孩子，另一个用于指向其下一个...
数据结构--树--双亲孩子表示法
weixin_43205582的博客
06-19 5977
双亲孩子表示法 双亲孩子表示法就是在每一个结点中添加一个firstchild指针域用来存放孩子链表指针，而且每个节点会有一个存放双亲结点在顺序存储结构中的索引，这样可以更好的查找到每个结点的双亲。但是问题是这得提前给出该树的结点数量，并生成内存空间。 下面用C++类来实现一个简单的类，这个树的创建中，每个结点后面最少会跟着一个孩子结点，且最后一个孩子结点是空的。 主要难点是在基于当前树的某一个结...
树的存储(双亲表示法)
weixin_42295110的博客
08-04 3342
此种方式找父节点好找,但是找子结点需要遍历整个数组。 删除某一个结点时:(思路) 1.该结点没有孩子,直接删除即可。 2.该结点有孩子,需要递归将孩子结点删除,然后再删除该结点。 删除时的小细节： 1.每删除一个元素时,将数组中的最后一个元素前移,节省存储空间,遍历数组时方便,遍历的元素少,但是存在问题。（F结点有子结点,F的子结点在未删除的情况,F结点进行了移动,导致F结点的下标发生了变化,继而导致 GHK与F结点失联。） 2.删...
树的三种表示法：双亲表示法、孩子表示法、孩子兄弟表示法
热门推荐
Huberyxiao的博客
03-25 2万+
抽象数据类型： 树的存储结构： 利用顺序存储和链式存储的特点，完全可以实现对树的存储结构的表示。介绍三种不同的表示法：双亲表示法、孩子表示法、孩子兄弟表示法。 1.双亲表示法 我们假设以一段连续空间存储树的结点，同时在每个结点中，附设一个指示器指示其双亲结点到链表中的位置。也就是说，每个结点除了直到自己是谁外，还要直到自己的双亲在哪里。如图： 其中data就是数据域，存储结点的信息。而paren...
树的双亲表示法(详解)——c语言形式
ThePythonFucker的博客
02-23 2519
双亲表示法采用一组连续的存储空间来存储每个节点，同时在每个节点中增设一个尾指针（指针用于指向其父节点在数组中的位置——即其父节点的数组下标） （图与后面代码均来源于王道数据结构考研复习指导） 如上图所示，(b)为树(a)在双亲表示法下的存储形式。 (b)中有三列数据 表格左侧外部一列（0 1 2 3 ...）为对应下标，即数组下标，代表节点的编号 根节点下标为0，其伪指针为-1（因为其没有父节点） 表格内第一列(data)为存储的各个节点，（图中顺序则是按树的层次遍历顺序排列）
二叉树练习（二）：树的双亲表示法及其部分算法实现
Melonl的博客
10-09 5282
双亲表示法，即储存树结点的同时储存其所属的父结点的表示法，通常利用顺序表（数组）实现。
数据结构c语言——树的三种存储结构（双亲表示法、孩子表示法、兄弟表示法）
girls的博客
06-20 1万+
在大量的应用中，人们曾使用多种形式的存储结构来表示树。这里,我们介绍3种常用的链表结构。 1.双亲表示法： 假设以一组连续空间存储树的结点，同时在每个结点中附设一个指示器指示其双亲结点在链表中的位置,其形式说明如下: 例如，图6.13展示一棵树及其双亲表示的存储结构。 这种存储结构利用了每个结点(除根以外)只有惟一的双亲的性质。PARENT(T,x)操作可以在常量时间内实现。反复调用PARENT操作，直到遇见无双亲的结点时，便找到了树的根,这就是ROOT(x)操作的执行过程。但是，在这种表示法中,求结点
树的存储结构-----1---双亲表示法
麦地与诗人
08-30 2640
双亲表示法 除了根结点外，其余每个结点，它不一定有孩子，但是一定有且只有一个双亲。 我们假设以一组连续空间存储树的结点，同时，在每个结点中，附设一个指示器指示其双亲结点在链表中的位置。 结点结构 data：数据域，存储结点的数据信息。 parent：指针域，存储该结点的双亲在数组中的下标。 实现 由于根结点是没有双亲的，所以，约定根结点的位置域设置为-1。 这样的存储结构，我们可以根据结点的...
数据结构与算法（6-1）树的存储（树的双亲表示、树的孩子表示及树的双亲孩子表示）
great_yzl的博客
08-02 1328
一、树的双亲表示 存储结构 采用结构体数组的形式存储数据。 （根结点parent=1：它没有双亲结点了） //树的双亲表示 typedef struct { char data; //结点数据 int parent; //双亲在数组中的位置 }Tree; Tree tree[MAXSIZE]; 总代码 //树的双亲表示法（双亲树） //getchar()：吸收换行符 #include<stdio.h> #define MAXSIZE 20 int cou...
数的双亲表示法结点结构定义
sunny_girl_123的博客
07-25 1282
//数的双亲表示法结点结构定义 #define MAX_TREE_SIZE 100 type int ElemType; typedef struct PTNode { ElemType data; //结点数据 int parent; //双亲位置 即数组的下标 } PTNode; typedef struct { PTNode nodes[MAX_TREE_SI
树和二叉树数据结构：双亲表示法与P-数据结构
"双亲表示类型的定义用于树和二叉树的数据结构中，具体为一个结构体`ptnode`，包含字符数据域和整型的双亲位置域。此外，还定义了一个`ptree`结构体，用于存储最大100个节点的树，包括根的位置和结点数。" 在数据...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值