树的存储结构

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

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)