树数据结构的低冗余存储方式

所需附加存储空间：n*size(int)，n是树的节点总数

树结构由数组形式顺序存储

例：

1:F

2:F11

3:F12

4:F13

5:F14

6:F211

7:F212

8:F221

9:F231

10:F232

11:F233

13:F322

12:F321

数组1（Array1）：存储节点内容

 

F	F11	F12	F13	F14	F211	F212	F221	F231	F232	F232	F321
F322

struct      Node

{

       int    number;  //序号

       nodetype content;   //内容

};

Node       Array1[];

数组2（Array2）：存储树结构信息

4	2	1	3	0	0	2	0	0	0	0	0
0

int    Array2[];

 

提供如下标准操作：

添加节点，添加子树，删除节点，删除子树，移动子树

 

 

获得父节点：

Node*     get_father_node  (Node*     node)

{

       int    tempno    =     node->number;

       int    i      =     0;

       int    count      =     0;

       int    fatherno;

       Node*     father;

       for(  i=0   ;      count      <     tempno    ;      i++  )

       {

              count      =     count      +     Array2[i] ;

}

fatherno  =     i;     //找到父节点

father      =     &Array1[fatherno];

//需要指针越界处理

return      father;

}

 

获得第一个子节点：

Node*     get_first_son_node  (Node* node)

{

       int    tempno    =     node->number;

int    i      =     0;

int    count      =     0;

int    sonno;

Node*     son;

for(  i=0   ;      i      <     tempno    ;      i++  )

       {

              count      =     count      +     Array2[i] ;

}

sonno      =     i      -      Array2[tempno]     +     1;    //找到子节点

son  =     &Array1[sonno];

//需要指针越界处理

return      son;

}

 

获得最后一个子节点：

Node*     get_last_son_node  (Node*  node)

{

       int    tempno    =     node->number;

int    i      =     0;

int    count      =     0;

int    sonno;

Node*     son;

for(  i=0   ;      i      <     tempno    ;      i++  )

       {

              count      =     count      +     Array2[i] ;

}

sonno      =     i;     //找到子节点

son  =     &Array1[sonno];

//需要指针越界处理

return      son;

}

 

添加节点：

insertnode       (Node*    node1,     Node*     node2)    //待添加节点node2，目标节点node1

{

       Node*     aimnode  =     get_last_son_node  (node1);

       int    tempno    =     aimnode->number;

       //申请一个比原长度大1的数组

       //从tempno后的数组元素依次后移一位，空出来的那一位装入node2

       //从tempno后的数组Array1元素依次修改序号，根据tempno依次加一

       //从tempno后的数组Array2元素如上修改，新插入位设为0

}

 

添加子树：

inserttree (Node*    node1,     Node*     node2,     int*  Array2pointer)       //待添加树首节点node2，目标节点node1，Array2pointer是指向待插入树的Array2数组的指针

{

Node*     backnode1      =     node1;

Node*     backnode2      =     node2;

       insertnode       (node1,   node2);

       node1      =     node2;

int    temp       =     node2->number;

node2      =     get_first_son_node (node1);

       for(  j      =     Array2pointer[temp];     j      >     0;    j--    )

       {

              inserttree(node1,    node2,     Array2pointer);

              node2++;

}

node1      =     backnode1;

node2      =     backnode2;

}

 

删除节点：

deletenode      (Node*    node)

{

       int    temp              =     node->number;

       Node*     node1      =     get_first_son_node(node);

       Node*     father      =     get_father_node(node);

       for(i =     0;    i      <     Array2[temp]; i++  )

       {

              tree  newtree   =     deldetetree(node1);

              Node*     treenode  =     newtree.node;

              int    Array[]    =     newtree.Array;

              inserttree(father,     treenode, &Array)

              node1++;

}

}

 

删除子树：

tree  deletetree        (Node*    node)

{

       Node*     tempnode              =     node;

       Node*     headnode        =     node;

int    soncount =     Array2[node->number];

int    array1pointer  =     0;

int    array2pointer  =     0;

int    i      =     0;

Node       nowArray1[];

int           nowArray2[];

nowArray1[0]        =     *headnode;

nowArray2[0]        =     Array2[headnode->number];

array1pointer++;

array2pointer++;

       while(soncount      !=    0)

       {

              tempnode              =     get_first_son_node(tempnode);

              for(i        =     0;    i      <     soncount ;      i++  )

              {

                     nowArray1[array1pointer]     =     &tempnode+i  ;

                     nowArray1[array1pointer].number       =     array1pointer;

                     nowArray2[array2pointer]     =     Array2[tempnode+i ->    number];

                     tempnode+i     ->    number   =     -1;   //标记出需要被删除的节点

                     array1pointer++;

                     array2pointer++;

}

endcount =     soncount;

soncount =     0;

for(i        =     0;    i      <     endcount      ;      i++)

{

       soncount =     Array2[tempnode->number   +     i]     +     soncount;

}

       }//遍历到这棵树的第一个叶子节点  

       for(i        =     0;    i      <     数组长度;      i++)

       {

              if(Array1[i].number       ==   -1)

              {

                     对于Array1[]和Array2[]数组，i+1开始所有元素向前挪一位;尾部删除一位，长度减一

              }

       }

       return                    将nowArray1[]和nowArray2[]付给一个tree形变量，返回结果，注意不是返回地址，而是复制值返回。所以两个数组必须被复制。以免函数析构后，指针悬空。

}

 

移动子树：

movetree        (Node*    node1,     Node*     node2)//node1是node2未来的父节点

{

       tree*              temptree;

       temptree  =     deletetree(node2);

       inserttree(node1,    temptree->Array1)；

}//剪切，粘贴