树的存储结构

南莺莺2025-10-01 14:08

前面我们讲过二叉树的存储方式，包括顺序存储和链式存储，但如果用存储二叉树的方式来存储树可以吗，这显然是不行的，因为二叉树是规律的树，比如说我们可以利用顺序存储的方式来存储二叉树，但是树不同于二叉树是多种多样的，所以我们需要使用其他方法

1.双亲表示法

具体思想:

用数组顺序存储各个结点。每个结点中保存数据元素、指向双亲结点(父结点)的指针

非根结点的双亲指针 = 父结点在数组中的下标

根节点的双亲指针 = -1(根结点没有父结点)

代码实现:

#include<stdio.h>

#include<stdbool.h>

#define Max 100

//成员表示

typedef struct

{

int data;//数据域

int parent;//父结点在数组里的位置

}TreeMember;

//数组表示

typedef struct

{

TreeMember arr[Max];//双亲表示

int num;//结点总数

}TreeArray;

//声明根结点

void InitTree(TreeArray* tree)

{

tree->arr[0].data = 1;

tree->arr[0].parent = -1;//根结点无父结点

tree->num = 1;

return;

}

//插入树

bool EnTree(TreeArray* tree)

{

if (tree == NULL)//无根结点

return false;

if (tree->num >= Max)//数组无空间

return false;

//手动方式创建

tree->arr[1].data = 2;

tree->arr[1].parent = 0;

tree->num++;

tree->arr[2].data = 3;

tree->arr[2].parent = 0;

tree->num++;

tree->arr[3].data = 4;

tree->arr[3].parent = 0;

tree->num++;

tree->arr[4].data = 5;

tree->arr[4].parent = 1;

tree->num++;

tree->arr[5].data = 6;

tree->arr[5].parent = 1;

tree->num++;

tree->arr[6].data = 7;

tree->arr[6].parent = 2;

tree->num++;

tree->arr[7].data = 8;

tree->arr[7].parent = 3;

tree->num++;

tree->arr[8].data = 9;

tree->arr[8].parent = 3;

tree->num++;

tree->arr[9].data = 10;

tree->arr[9].parent = 3;

tree->num++;

tree->arr[10].data = 11;

tree->arr[10].parent = 4;

tree->num++;

return true;

}

//寻找父结点

bool FindParent(TreeArray* tree)

{

if (tree == NULL)

return false;//空树没有父结点

int n;

printf("输入孩子结点(9999退出)\n");

scanf("%d", &n);

while (n != 9999)//假设输入9999退出

{

if (n == 1)

return false;//根节点无父节点

if (n < 0 && n >= tree->num)

return false;//输入不合法

int parent = tree->arr[n - 1].parent;

printf("父节点为%d\n",tree->arr[parent].data);

printf("输入孩子结点(9999退出)\n");

scanf("%d", &n);

}

return true;

}

//寻找孩子结点

bool FindSon(TreeArray* tree)

{

if (tree == NULL)//表示空树

return false;

printf("请输入要寻找的孩子结点:\n");

int n;

scanf("%d", &n);

if (n < 0 && n > tree->num)

return false;//输入错误

int i = 0;

int flag = 0;

for (i = 0; i < tree->num; i++)

{

if (tree->arr[i].parent == n - 1)

{

printf("%d的孩子结点为%d\n", n, tree->arr[i].data);

flag++;

}

}

if (flag == 0)

printf("没找到\n");

return true;

}

int main()

{

TreeArray tree;//声明一棵树

InitTree(&tree);//初始化根结点

EnTree(&tree);//插入结点

FindParent(&tree);//假设寻找5的父结点

FindSon(&tree);

return 0;

}

//寻找父结点的时间复杂度为O(1)

//寻找孩子结点的时间复杂度为O(n)

优缺点:

优点:找双亲(父结点)很方便

缺点:找孩子不方便，只能从头到尾遍历真个数组

2.孩子表示法

具体思想:用数组顺序存储各个结点。每个结点中保存数据元素、孩子链表头指针

代码实现:

#include <stdio.h>

#include <stdbool.h>

#include <stdlib.h>

#define Max 100

//定义链表(孩子结点)

typedef struct LinkNode

{

int place;//数据域,存在孩子在数组里的位置

struct LinkNode* next;//指针域

}LinkNode;

//定义成员

typedef struct TreeMember

{

int data;//数据域

struct LinkNode* FirstChild;//指针域(第一个孩子的地址)

}TreeMember;

//定义数组

typedef struct TreeArray

{

TreeMember arr[Max];

int root;//根结点的位置

int num;//总数

}TreeArray;

//初始化数组

void InitTree(TreeArray* Tree)

{

Tree->arr[0].data = 1;//初始化根节点为1

Tree->arr[0].FirstChild = NULL;//孩子结点暂时为空

Tree->root = 0;

Tree->num = 1;

}

//增加树结点

bool EnTree(TreeArray* Tree)

{

//插入树结点

if (Tree->num < Max)

{

Tree->arr[1].data = 2;

Tree->arr[1].FirstChild = NULL;

Tree->num++;

Tree->arr[0].FirstChild = (LinkNode*)malloc(sizeof(LinkNode));//创建根结点的孩子指针

if (Tree->arr[0].FirstChild == NULL)

return false;//分配失败

Tree->arr[0].FirstChild->place = 1;

Tree->arr[0].FirstChild->next = NULL;

LinkNode* q = Tree->arr[0].FirstChild;

int number = 3;

for (int i = 2; i <= 3; i++)

{

Tree->arr[i].data = number;

Tree->arr[i].FirstChild = NULL;//孩子结点指向空

Tree->num++;

LinkNode* p = (LinkNode*)malloc(sizeof(LinkNode));

if (p == NULL)

return false;//分配失败

q->next = p;

p->next = NULL;

p->place = i;

q = p;

number++;

}

Tree->arr[4].data = 5;

Tree->arr[4].FirstChild = NULL;

Tree->num++;

Tree->arr[1].FirstChild = (LinkNode*)malloc(sizeof(LinkNode));

if (Tree->arr[1].FirstChild == NULL)

return false;//分配失败

Tree->arr[1].FirstChild->place = 4;

Tree->arr[1].FirstChild->next = NULL;

Tree->arr[5].data = 6;

Tree->arr[5].FirstChild = NULL;

Tree->num++;

Tree->arr[1].FirstChild->next = (LinkNode*)malloc(sizeof(LinkNode));

if (Tree->arr[1].FirstChild->next == NULL)

return false;//分配失败

Tree->arr[1].FirstChild->next->place = 5;

Tree->arr[1].FirstChild->next->next = NULL;

Tree->arr[6].data = 7;

Tree->arr[6].FirstChild = NULL;

Tree->num++;

Tree->arr[2].FirstChild = (LinkNode*)malloc(sizeof(LinkNode));

if (Tree->arr[2].FirstChild == NULL)

return false;//分配失败

Tree->arr[2].FirstChild->place = 6;

Tree->arr[2].FirstChild->next = NULL;

Tree->arr[7].data = 8;

Tree->arr[7].FirstChild = NULL;

Tree->num++;

Tree->arr[3].FirstChild = (LinkNode*)malloc(sizeof(LinkNode));

if (Tree->arr[3].FirstChild == NULL)

return false;

Tree->arr[3].FirstChild->place = 7;

Tree->arr[3].FirstChild->next = NULL;

LinkNode* s = Tree->arr[3].FirstChild;

int j;

for (j = 8; j <= 9; j++)

{

Tree->arr[j].data = j + 1;

Tree->arr[j].FirstChild = NULL;

Tree->num++;

LinkNode* x = (LinkNode*)malloc(sizeof(LinkNode));

if (x == NULL)

return false;//分配失败

s->next = x;

x->next = NULL;

x->place = j;

s = x;

}

}

return true;

}

//寻找孩子结点

bool FindSon(TreeArray* Tree,int n)

{

if (Tree == NULL)

return false;

if (Tree->arr[n - 1].FirstChild == NULL)

{

printf("无孩子结点\n");

return false;

}

//n - 1是当前结点的位置

LinkNode* p = Tree->arr[n - 1].FirstChild;

while (p != NULL)

{

printf("%d的孩子结点为%d\n", n, Tree->arr[p->place].data);

p = p->next;

}

return true;

}

//寻找父亲结点

bool FindPar(TreeArray* Tree,int n)

{

if (Tree == NULL)

return false;//空树

if (n == Tree->root)

return false;//根结点无父结点

int i;

for (i = 0; i < Tree->num; i++)

{

LinkNode* p = Tree->arr[i].FirstChild;

int number = p->place;

while (p != NULL)

{

if (Tree->arr[number].data == Tree->arr[n - 1].data)

{

printf("%d的父结点为%d\n", n, Tree->arr[i].data);

return true;//找到了

}

else

{

p = p->next;

number = p->place;

}

}

}

return true;

}

int main()

{

TreeArray Tree;//定义一棵树

InitTree(&Tree);//初始化根结点

EnTree(&Tree);//新增树结点

FindSon(&Tree,4);//找孩子结点,假设寻找结点元素为4的孩子结点

FindPar(&Tree,4);//寻找父结点,假设寻找结点元素为4的父亲结点

return 0;

//找父结点的时间复杂度为O(n^2)

//找孩子结点的时间复杂度为O(1)

//空间复杂度O(n)

//用双亲方式存储还是用孩子方式存储各有利弊，要根据实际情况来使用更方便的一种方式

3.孩子兄弟表示法

具体思想:类似与二叉树的存储方式，构建两个指针，分别存储首个孩子指针和右兄弟指针

代码实现:

#include<stdio.h>

#include<stdlib.h>

#include<stdbool.h>

typedef struct TreeNode

{

int data;//数据域

struct TreeNode* firstchild, *rightbrother;//指针域(第一个孩子和右兄弟)

}TreeNode,*Tree;

//初始化

void InitTree(Tree* T)

{

(*T) = (TreeNode*)malloc(sizeof(TreeNode));//创建根结点

if ((*T) == NULL)

return;//分配失败

(*T)->firstchild = NULL;

(*T)->rightbrother = NULL;

return;

}

//插入树结点

bool EnTree(Tree* T)

{

if ((*T) == NULL)

return false;//没有根结点

TreeNode* p1 = (*T);

TreeNode*p2 = (TreeNode*)malloc(sizeof(TreeNode));

if (p2 == NULL)

return false;//创建失败

p2->data = 2;

p2->firstchild = NULL;

p2->rightbrother = NULL;

p1->firstchild = p2;

TreeNode* p3 = (TreeNode*)malloc(sizeof(TreeNode));

if (p3 == NULL)

return false;

p3->data = 3;

p3->firstchild = NULL;

p3->rightbrother = NULL;

p2->rightbrother = p3;

TreeNode* p4 = (TreeNode*)malloc(sizeof(TreeNode));

if (p4 == NULL)

return false;

p4->data = 4;

p4->firstchild = NULL;

p4->rightbrother = NULL;

p3->rightbrother = p4;

TreeNode* p5 = (TreeNode*)malloc(sizeof(TreeNode));

if (p5 == NULL)

return false;

p5->data = 5;

p5->firstchild = NULL;

p5->rightbrother = NULL;

p2->firstchild = p5;

TreeNode* p6 = (TreeNode*)malloc(sizeof(TreeNode));

if (p6 == NULL)

return false;

p6->data = 6;

p6->firstchild = NULL;

p6->rightbrother = NULL;

p5->rightbrother = p6;

TreeNode* p7 = (TreeNode*)malloc(sizeof(TreeNode));

if (p7 == NULL)

return false;

p7->data = 7;

p7->firstchild = NULL;

p7->rightbrother = NULL;

p3->firstchild = p7;

TreeNode* p8 = (TreeNode*)malloc(sizeof(TreeNode));

if (p8 == NULL)

return false;

p8->data = 8;

p8->firstchild = NULL;

p8->rightbrother = NULL;

p4->firstchild = p8;

TreeNode* p9 = (TreeNode*)malloc(sizeof(TreeNode));

if (p9 == NULL)

return false;

p9->data = 9;

p9->firstchild = NULL;

p9->rightbrother = NULL;

p8->rightbrother = p9;

TreeNode* p10 = (TreeNode*)malloc(sizeof(TreeNode));

if (p10 == NULL)

return false;

p10->data = 10;

p10->firstchild = NULL;

p10->rightbrother = NULL;

p9->rightbrother = p10;

return true;

}

//寻找孩子结点

//遍历树找到结点

TreeNode* PreTree(Tree T, int n)

{

if (T != NULL)

{

if (T->data == n)

return T;

//先找孩子结点

TreeNode* child = PreTree(T->firstchild,n);

if (child != NULL)

return child;

//再找兄弟结点

TreeNode*brother = PreTree(T->rightbrother, n);

if (brother != NULL)

return brother;

}

return NULL;

}

//寻找孩子结点

bool FindSon(Tree* T, int n)

{

if ((*T) == NULL)

return false;//空树

TreeNode * q = PreTree((*T), n);

if (q == NULL)

{

printf("不存在该结点\n");

return false;

}

if (q->firstchild == NULL)

{

printf("没有孩子结点\n");

return false;

}

TreeNode* s = q->firstchild;

while (s != NULL)

{

printf("%d的孩子结点为%d\n", n, s->data);

s = s->rightbrother;

}

return true;

}

int main()

{

Tree T;//构建树

InitTree(&T);//初始化树

EnTree(&T);//插入树结点

FindSon(&T,4);//假设寻找结点为4的孩子结点

return 0;

}

//寻找孩子结点的时间复杂度O(n)

//用该方法寻找父结点必须要加上一个格外的parent成员，否则无法寻找父结点及其困难

//空间复杂度为O(n)

相关推荐
workflower3 小时前
单元测试-例子
java·开发语言·算法·django·个人开发·结对编程
MicroTech20255 小时前
微算法科技（MLGO）研发突破性低复杂度CFG算法，成功缓解边缘分裂学习中的掉队者问题
科技·学习·算法
墨染点香5 小时前
LeetCode 刷题【126. 单词接龙 II】
算法·leetcode·职场和发展
aloha_7896 小时前
力扣hot100做题整理91-100
数据结构·算法·leetcode
Tiny番茄6 小时前
31.下一个排列
数据结构·python·算法·leetcode
挂科是不可能出现的6 小时前
最长连续序列
数据结构·c++·算法
_Aaron___6 小时前
List.subList() 返回值为什么不能强转成 ArrayList
数据结构·windows·list
前端小L7 小时前
动态规划的“数学之魂”：从DP推演到质因数分解——巧解「只有两个键的键盘」
算法·动态规划
RTC老炮7 小时前
webrtc弱网-ReceiveSideCongestionController类源码分析及算法原理
网络·算法·webrtc
21号 17 小时前
9.Redis 集群（重在理解）
数据库·redis·算法
热门推荐
01GitHub 镜像站点02BongoCat - 跨平台键盘猫动画工具03UV安装并设置国内源04Linux下V2Ray安装配置指南05GitLab 零基础入门指南：从安装到项目管理全流程06NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南07一文了解国产算子编程语言 TileLang，TileLang 对国产开源生态的影响与启示08KGG转MP3工具|非KGM文件|解密音频09在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）102025软件测试面试八股文（含答案+文档）