第九周项目4——-广义表算法库及应用（2）

1. /*  
2. * Copyright (c)2016,烟台大学计算机与控制工程学院  
3. * All rights reserved.  
4. * 文件名称：wu.cpp  
5. * 作    者：武昊  
6. * 完成日期：2016年10月27日  
7. * 版 本 号：v1.0   
8. *问题描述：设计算法，求出给定广义表g中的原子个数和最大原子 
9. *输入描述：无  
10. *程序输出：测试数据  
11. */  

glist.h:

1. #include <stdio.h>  
2. #include <malloc.h>  
3. typedef char ElemType;  
4. typedef struct lnode  
5. {  
6.     int tag;                    //节点类型标识  
7.     union  
8.     {  
9.         ElemType data;          //原子值  
10.         struct lnode *sublist;  //指向子表的指针  
11.     } val;  
12.     struct lnode *link;         //指向下一个元素  
13. } GLNode;                       //广义表节点类型定义  
14.   
15. int GLLength(GLNode *g);        //求广义表g的长度  
16. int GLDepth(GLNode *g);     //求广义表g的深度  
17. GLNode *CreateGL(char *&s);     //返回由括号表示法表示s的广义表链式存储结构  
18. void DispGL(GLNode *g);                 //输出广义表g  
    

 glist.cpp:

1. #include "glist.h"  
2. int GLLength(GLNode *g)     //求广义表g的长度  
3. {  
4.     int n=0;  
5.     GLNode *g1;  
6.     g1=g->val.sublist;      //g指向广义表的第一个元素  
7.     while (g1!=NULL)  
8.     {  
9.         n++;                //累加元素个数  
10.         g1=g1->link;  
11.     }  
12.     return n;  
13. }  
14.   
15. int GLDepth(GLNode *g)      //求广义表g的深度  
16. {  
17.     GLNode *g1;  
18.     int max=0,dep;  
19.     if (g->tag==0)          //为原子时返回0  
20.         return 0;  
21.     g1=g->val.sublist;      //g1指向第一个元素  
22.     if (g1==NULL)           //为空表时返回1  
23.         return 1;  
24.     while (g1!=NULL)        //遍历表中的每一个元素  
25.     {  
26.         if (g1->tag==1)     //元素为子表的情况  
27.         {  
28.             dep=GLDepth(g1);    //递归调用求出子表的深度  
29.             if (dep>max)    //max为同一层所求过的子表中深度的最大值  
30.                 max=dep;  
31.         }  
32.         g1=g1->link;            //使g1指向下一个元素  
33.     }  
34.     return(max+1);          //返回表的深度  
35. }  
36.   
37. GLNode *CreateGL(char *&s)      //返回由括号表示法表示s的广义表链式存储结构  
38. {  
39.     GLNode *g;  
40.     char ch=*s++;                       //取一个字符  
41.     if (ch!='\0')                      //串未结束判断  
42.     {  
43.         g=(GLNode *)malloc(sizeof(GLNode));//创建一个新节点  
44.         if (ch=='(')                    //当前字符为左括号时  
45.         {  
46.             g->tag=1;                   //新节点作为表头节点  
47.             g->val.sublist=CreateGL(s); //递归构造子表并链到表头节点  
48.         }  
49.         else if (ch==')')  
50.             g=NULL;                     //遇到')'字符,g置为空  
51.         else if (ch=='#')               //遇到'#'字符，表示为空表  
52.             g=NULL;  
53.         else                            //为原子字符  
54.         {  
55.             g->tag=0;                   //新节点作为原子节点  
56.             g->val.data=ch;  
57.         }  
58.     }  
59.     else                                 //串结束,g置为空  
60.         g=NULL;  
61.     ch=*s++;                            //取下一个字符  
62.     if (g!=NULL)                        //串未结束，继续构造兄弟节点  
63.     {  
64.         if (ch==',')                    //当前字符为','  
65.             g->link=CreateGL(s);        //递归构造兄弟节点  
66.         else                            //没有兄弟了,将兄弟指针置为NULL  
67.             g->link=NULL;  
68.     }  
69.   
70.     return g;                           //返回广义表g  
71. }  
72.   
73. void DispGL(GLNode *g)                  //输出广义表g  
74. {  
75.     if (g!=NULL)                        //表不为空判断  
76.     {  
77.         //先处理g的元素  
78.         if (g->tag==0)                  //g的元素为原子时  
79.             printf("%c", g->val.data);  //输出原子值  
80.         else                            //g的元素为子表时  
81.         {  
82.             printf("(");                //输出'('  
83.             if (g->val.sublist==NULL)   //为空表时  
84.                 printf("#");  
85.             else                        //为非空子表时  
86.                 DispGL(g->val.sublist); //递归输出子表  
87.             printf(")");                //输出')'  
88.         }  
89.         if (g->link!=NULL)  
90.         {  
91.             printf(",");  
92.             DispGL(g->link);            //递归输出后续表的内容  
93.         }  
94.     }  
95. }  

main.cpp：

1. #include <stdio.h>  
2. #include "glist.h"  
3.   
4. int atomnum(GLNode *g)  //求广义表g中的原子个数  
5. {  
6.     if (g!=NULL)  
7.     {  
8.         if (g->tag==0)  
9.             return 1+atomnum(g->link);  
10.         else  
11.             return atomnum(g->val.sublist)+atomnum(g->link);  
12.     }  
13.     else  
14.         return 0;  
15. }  
16.   
17. ElemType maxatom(GLNode *g)             //求广义表g中最大原子  
18. {  
19.     ElemType max1,max2;  
20.     if (g!=NULL)  
21.     {  
22.         if (g->tag==0)  
23.         {  
24.             max1=maxatom(g->link);  
25.             return(g->val.data>max1?g->val.data:max1);  
26.         }  
27.         else  
28.         {  
29.             max1=maxatom(g->val.sublist);  
30.             max2=maxatom(g->link);  
31.             return(max1>max2?max1:max2);  
32.         }  
33.     }  
34.     else  
35.         return 0;  
36. }  
37.   
38. int main()  
39. {  
40.     GLNode *g;  
41.     char *s="(b,(b,a,(#),d),((a,b),c((#))))";  
42.     g = CreateGL(s);  
43.     DispGL(g);  
44.     printf("\n");  
45.     printf("原子个数 :%d\n", atomnum(g));  
46.     printf("最大原子 :%c\n", maxatom(g));  
47.     return 0;  
48. }  

总结：

利用广义表的递归性来解决问题。