树结构存储表示

Posted 2021-03-09 zww-kjj

对于双亲表示法：我们先将双亲结点存入，我们每插入一个结点都是知道双亲结点位置的，数据可以直接插入。使用顺序存储结构更加方便
而对于孩子表示法，我们每次插入一个结点，对其子树的位置存放暂不确定，所有使用链式存储结构占主要

（一）双亲表示法

以双亲作为索引的关键词的一种存储方式
每个结点只有一个双亲，所以选择顺序存储占主要
以一组连续空间存储树的结点，同时在每个结点中，附设一个指示其双亲结点位置的指针域
结点:

 

 

#include<iostream>
#include<cstring>
const int MAXN=100;
using namespace std;

struct node
{//双亲表示法. 
    char val;//值 
    int par;//父亲 
};
node L[MAXN];
int length;
bool vis[MAXN];
void print(int root)
{//这个程序不用担心产生环. 
    if(root<length)
    {
        cout<<L[root].val<<" "; vis[root]=true;
        for(int i=0;i<length;i++)
            if(!vis[i]&&L[i].par==root) print(i);
　　　　　　　//这个地方是有瑕疵的,其实不必有vis的判断,因为树本身的性质决定了它不可能存在图的遍历中可能存在的环,也就排除了重复访问的可能性.
    }
    return ;
}

void init(int n)
{
    for(int i=0;i<n;i++) L[i].par=-1,vis[i]=false;
    
}

int main()
{
    int n;
    char chx,chy;
    cin>>n;
    length=n;
    init(n);
    for(int i=0;i<n-1;i++)
    {
        int x,y;
        cin>>x>>chx>>y>>chy;
        L[x].val=chx; L[y].val=chy;
        L[y].par=x;
    }
    print(0);
    return 0;
}
/*
10
0 a 1 b
0 a 2 c
1 b 3 d
3 d 6 g
3 d 7 h
3 d 8 i
2 c 4 e
2 c 5 f
4 e 9 j
a b d g h i c e j f
*/

 

其实以上的双亲表示法虽然简单,但是也是有缺陷的,那就是在短时间内不容易快速写出.如何才能快速写出呢?

  int par[maxn];//par[i]表示i结点的父亲下标     int val[maxn];//val[i]表示i结点对应的值.  

以上代码即可.

二.孩子表示法.

 1 #include<iostream>
 2 #include<cstring>
 3 using namespace std;
 4 
 5 //孩子表示法;
 6 //即每个树结点都有孩子索引域 
 7 
 8 struct node
 9 {//degree=2
10     char val;
11     int left,right;
12 }a[1001];
13 int n;
14 void init()
15 {
16     for(int i=0;i<n;i++) a[i].val=1,a[i].left=a[i].right=-1;
17 }
18 
19 void print(int root)
20 {
21     if(root<n)
22     {
23         cout<<a[root].val<<" ";
24         if(a[root].left!=-1) print(a[root].left);
25         if(a[root].right!=-1) print(a[root].right);
26     }
27     return ;
28 }
29 
30 
31 int main()
32 {
33     int cnt=0,x,y;
34     char chx,chy;
35     cin>>n;
36     init();
37     while(1)
38     {
39         if(cnt==n-1) break;
40         cin>>x>>chx>>y>>chy;
41         a[x].val=chx; a[y].val=chy; 
42         if(a[x].left==-1) a[x].left=y;
43         else a[x].right=y;
44         cnt++; 
45     }
46     print(0);
47     return 0;
48 }

以上就是孩子表示法,其实这是有很大瑕疵的,因为一个结点不容易找到它的爹,所以我们可以在结点的内部增加一个域用以表示其父亲也是可以的

正如:

1 struct node
2 {//degree=2
3     char val;
4     int par;
5     int left,right;
6 }

其实这样的改进也是不太好的.

为什么呢?

你怎么知道树的度是多少呢?

那如何呢?

看下面:

1 struct node
2 {//degree=2
3     char val;
4 　　 int par;
5     int child[max_degree];
6 }

看吧,儿子好找了,爹也好找了.但是我们看,这...是不是太浪费空间了?

如何优化呢?

不急,看图.

 

 

两种线性表的结合是不是很不错呢?
具体怎么运用呢?
自己琢磨去!

三.孩子兄弟法.
下面就是孩子兄弟法了,具体是:

1 struct node
2 {
3     char val;
4     node *firstchild,*next_sibling;
5 };

可以看出,结点的内容是存储每一个结点的第一个孩子以及此结点的兄弟.
可以看出,我们既优化了每个父亲对多个孩子的索引的简化,又能使得每个结点可以轻松的访问它的众多兄弟,
其实在xpath和dom树中对结点的兄弟的获取就是靠着这种结构而构造成的.

代码为:

 1 #include<iostream>
 2 #include<cstring>
 3 using namespace std;
 4 
 5 //孩子表示法;
 6 //即每个树结点都有孩子索引域 
 7 struct node
 8 {
 9     char val;
10     node *firstchild,*next_sibling;
11 }a[1001];
12 int n;
13 void init()
14 {
15     for(int i=0;i<n;i++) a[i].val=1,a[i].firstchild=a[i].next_sibling=NULL;
16 }
17 
18 void print(node *root)
19 {
20     if(root!=NULL)
21     {
22         cout<<root->val<<" ";
23         node* temp=root->firstchild; 
24         while(temp)
25         {
26             print(temp);
27             temp=temp->next_sibling;
28         }
29     }
30     return ;
31 }
32 
33 
34 int main()
35 {
36     int cnt=0,x,y;
37     char chx,chy;
38     cin>>n;
39     init();
40     while(1)
41     {
42         if(cnt==n-1) break;
43         cin>>x>>chx>>y>>chy;
44         a[x].val=chx; a[y].val=chy; 
45         if(!a[x].firstchild) a[x].firstchild=&a[y];
46         else
47         {
48             node * temp=a[x].firstchild,*fa=NULL;
49             while(temp) fa=temp,temp=temp->next_sibling;
50             fa->next_sibling=&a[y];
51         }
52         cnt++; 
53     }
54     print(&a[0]);
55     return 0;
56 }

以上就是这三种基本的树的存储结构,

里面还掺杂了一些优化缘由(无非是为了满足我们的某种需求而需要设计较好的数据结构)

以及优化后的结果.

其中三段大代码的输入数据都是一样的.

且结点的数据结构都是靠着数组来设计的.

好了,关于树的存储也告一段落了.

欢迎批评指正.

以下是两份我觉得写的很不错的博文.值得参考.
https://www.cnblogs.com/jpfss/p/10842521.html　　梗概
https://www.cnblogs.com/ssyfj/p/9459887.html　　优化.