1 /****************************************************
2 * *
3 * 文件夹: ▲05 数组和广义表\05 GeneralizedList-H&T *
4 * *
5 * 文件名: GeneralizedList-H-T.h *
6 * *
7 * 内 容: 广义表（头尾链表存储表示）相关操作列表 *
8 * *
9 ****************************************************/
10
11 #ifndef GENERALIZEDLIST_H_T_H
12 #define GENERALIZEDLIST_H_T_H
13
14 #include <stdio.h>
15 #include <stdlib.h> //提供malloc、realloc、free、exit原型
16 #include "../../01 绪论/Status.h" //**▲01 绪论**//
17 #include "../../04 串/01 SequenceString/SequenceString.c" //**▲04 串**//
18
19 /* 广义表（头尾链表存储表示）类型定义 */
20 typedef enum{ Head, Tail }Mark;
21 typedef enum{ Atom, List }ElemTag; //Atom==0：原子结点，List==1：表结点
22 typedef char AtomType; //原子类型
23 typedef struct GLNode
24 {
25 union{ int mark; }; //匿名联合，仅在第8章广义表遍历算法中使用
26
27 ElemTag tag; //公共部分，用于区分原子结点和表结点
28 union //原子结点和表结点的联合部分
29 {
30 AtomType atom; //atom是原子结点的值域，AtomType由用户定义
31 struct
32 {
33 struct GLNode *hp; //指向表头
34 struct GLNode *tp; //指向表尾
35 }ptr; //表结点的指针域
36 }Union;
37 }GLNode;
38 typedef GLNode* GList; //广义表类型
39
40 /* 广义表（头尾链表存储）函数列表 */
41 /* ★每一层去掉括号考察★ */
42 void InitGList_GL_H_T(GList *L);
43 /*━━━━━━━━━━━━━━━━━━━┓
44 ┃(01)初始化广义链表（创建空的广义表）。┃
45 ┗━━━━━━━━━━━━━━━━━━━*/
46
47 void sever_GL_H_T_1(SString hstr, SString str);
48 /*━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
49 ┃(02-1)算法5.8：将非空串str分割成两部分:hsub为第一个','之前的子串,str为之后的子串。┃
50 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━*/
51
52 void CreateGList_GL_H_T_1(GList *L, SString S);
53 /*━━━━━━━━━━━━━━━┓
54 ┃(03-1)算法5.7：由S创建广义表。┃
55 ┗━━━━━━━━━━━━━━━*/
56
57 void sever_GL_H_T_2(SString hstr, SString str);
58 /*━━━━━━━━━━━━━━━━━━━━━━━━━━┓
59 ┃(02-2)将非空串str分割成两部分:hsub做表头,str做表尾。┃
60 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━*/
61
62 void CreateGList_GL_H_T_2(GList *L, SString S);
63 /*━━━━━━━━━━━┓
64 ┃(03-2)由S创建广义表。 ┃
65 ┗━━━━━━━━━━━*/
66
67 void ClearGList_GL_H_T(GList *L);
68 /*━━━━━━━━━━━━━━┓
69 ┃(04)清空广义表（无法销毁）。┃
70 ┗━━━━━━━━━━━━━━*/
71
72 void CopyGList_GL_H_T(GList *T, GList L);
73 /*━━━━━━━━━━━━━┓
74 ┃(05)算法5.6：复制广义表。 ┃
75 ┗━━━━━━━━━━━━━*/
76
77 int GListLength_GL_H_T(GList L);
78 /*━━━━━━━━━┓
79 ┃(06)求广义表长度。┃
80 ┗━━━━━━━━━*/
81
82 int GListDepth_GL_H_T(GList L);
83 /*━━━━━━━━━━━━━━┓
84 ┃(07)算法5.5：求广义表深度。 ┃
85 ┗━━━━━━━━━━━━━━*/
86
87 Status GListEmpty_GL_H_T(GList L);
88 /*━━━━━━━━━━━━┓
89 ┃(08)判断广义表是否为空。┃
90 ┗━━━━━━━━━━━━*/
91
92 GList GetHead_GL_H_T(GList L);
93 /*━━━━━━━┓
94 ┃(09)获取表头。┃
95 ┗━━━━━━━*/
96
97 GList GetTail_GL_H_T(GList L);
98 /*━━━━━━━┓
99 ┃(10)获取表尾。┃
100 ┗━━━━━━━*/
101
102 void InsertFirst_GL_H_T(GList *L, GList e);
103 /*━━━━━━━━━━━━━━━┓
104 ┃(11)插入e为广义表第一个元素。 ┃
105 ┗━━━━━━━━━━━━━━━*/
106
107 void DeleteFirst_GL_H_T(GList *L, GList *e);
108 /*━━━━━━━━━━━━━━━┓
109 ┃(12)删除广义表表头并用e返回。 ┃
110 ┗━━━━━━━━━━━━━━━*/
111
112 void Traverse_GL_H_T(GList L, void(Visit)(AtomType));
113 /*━━━━━━━━┓
114 ┃(13)遍历广义表。┃
115 ┗━━━━━━━━*/
116
117 void Output_GL_H_T(GList L, Mark mark);
118 /*━━━━━━━━━━━━━━━━━━┓
119 ┃(14)带括号输出广义表L，mark为标记。 ┃
120 ┗━━━━━━━━━━━━━━━━━━*/
121
122 #endif
1 /****************************************************
2 * *
3 * 文件夹: ▲05 数组和广义表\05 GeneralizedList-H&T *
4 * *
5 * 文件名: GeneralizedList-H-T.c *
6 * *
7 * 算 法: 5.5、5.6、5.7、5.8 *
8 * *
9 ****************************************************/
10
11 #ifndef GENERALIZEDLIST_H_T_C
12 #define GENERALIZEDLIST_H_T_C
13
14 #include "GeneralizedList-H-T.h" //**▲05 数组和广义表**//
15
16 void InitGList_GL_H_T(GList *L)
17 {
18 *L = NULL; //初始化了一个空表，长度为0，深度为1
19 }
20
21 /*════╗
22 ║ 算法5.8║
23 ╚════*/
24 /* 假设广义表各字符间无空格，且输入正确 */
25 void sever_GL_H_T_1(SString hstr, SString str) //str最外层已无括号
26 {
27 int i, k, n;
28 SString ch;
29
30 n = StrLength_Sq(str);
31
32 i = k = 0;
33 do
34 {
35 ++i;
36 SubString_Sq(ch, str, i, 1);
37 if(ch[1]=='(')
38 ++k;
39 if(ch[1]==')')
40 --k;
41 }while(i<n && (ch[1]!=',' || k!=0));
42
43 if(i<n)
44 {
45 SubString_Sq(hstr, str, 1, i-1);
46 SubString_Sq(str, str, i+1, n-i);
47 }
48 else
49 {
50 StrCopy_Sq(hstr, str);
51 ClearString_Sq(str);
52 }
53 }
54
55 /*════╗
56 ║ 算法5.7║
57 ╚════*/
58 void CreateGList_GL_H_T_1(GList *L, SString S)
59 {
60 SString emp, hsub, sub;
61 GList p, q;
62
63 StrAssign_Sq(emp, "()");
64
65 if(!StrCompare_Sq(S, emp)) //S代表空表
66 *L = NULL; //创建空表
67 else
68 {
69 *L = (GList)malloc(sizeof(GLNode));
70 if(!*L)
71 exit(OVERFLOW);
72
73 if(StrLength_Sq(S)==1) //创建单原子广义表
74 {
75 (*L)->tag = Atom;
76 (*L)->Union.atom = S[1];
77
78 (*L)->mark = 0; //GarbageCollection.c
79 }
80 else
81 {
82 (*L)->tag = List;
83
84 (*L)->mark = 0; //GarbageCollection.c
85
86 p = *L;
87
88 SubString_Sq(sub, S, 2, StrLength_Sq(S)-2); //去掉最外层括号
89
90 do //重复建n个子表
91 {
92 sever_GL_H_T_1(hsub, sub); //分离出表头串hsub
93 CreateGList_GL_H_T_1(&(p->Union.ptr.hp), hsub);
94 q = p;
95 if(!StrEmpty_Sq(sub)) //表尾不为空，处理表尾
96 {
97 p = (GList)malloc(sizeof(GLNode));
98 if(!p)
99 exit(OVERFLOW);
100
101 p->tag = List;
102
103 p->mark = 0; //GarbageCollection.c
104
105 q->Union.ptr.tp = p;
106 }
107 }while(!StrEmpty_Sq(sub));
108 q->Union.ptr.tp = NULL;
109 }
110 }
111 }
112
113 /* 另一种创建广义表的算法，与上述算法略有不同 */
114 /* 假设广义表各字符间无空格，且输入正确 */
115 void sever_GL_H_T_2(SString hstr, SString str) //将str分解为表头元素和表尾元素两部分
116 {
117 int i = 1;
118 int k = 0;
119 int n;
120 SString tmp;
121
122 SubString_Sq(tmp, str, 2, StrLength_Sq(str)-2);
123
124 n = StrLength_Sq(tmp);
125
126 while(i<n && (tmp[i]!=',' || k!=0))
127 {
128 if(tmp[i]=='(')
129 k++;
130 if(tmp[i]==')')
131 k--;
132 i++;
133 }
134
135 if(i<n)
136 SubString_Sq(hstr, tmp, 1, i-1);
137 else
138 StrCopy_Sq(hstr, tmp);
139
140 StrDelete_Sq(str, 2, i);
141 }
142
143 void CreateGList_GL_H_T_2(GList *L, SString S)
144 {
145 SString hsub, sub, emp;
146 GList p, q;
147
148 StrAssign_Sq(emp, "()");
149
150 if(!StrCompare_Sq(S, emp))
151 *L = NULL;
152 else
153 {
154 *L = (GList)malloc(sizeof(GLNode));
155
156 if(StrLength_Sq(S)==1)
157 {
158 (*L)->tag = Atom;
159 (*L)->Union.atom = S[1];
160 }
161 else
162 {
163 (*L)->tag = List;
164 p = *L;
165
166 StrCopy_Sq(sub, S);
167
168 do
169 {
170 sever_GL_H_T_2(hsub, sub);
171 CreateGList_GL_H_T_2(&(p->Union.ptr.hp), hsub);
172
173 if(StrCompare_Sq(sub, emp))
174 {
175 q = p;
176 p = (GList)malloc(sizeof(GLNode));
177 p->tag = List;
178 q->Union.ptr.tp = p;
179 }
180 }while(StrCompare_Sq(sub, emp));
181 p->Union.ptr.tp = NULL;
182 }
183 }
184 }
185
186 void ClearGList_GL_H_T(GList *L)
187 {
188 GList p, q;
189
190 if(*L)
191 {
192 if((*L)->tag==Atom)
193 {
194 free(*L); //删除原子结点
195 *L = NULL;
196 }
197 else //删除表结点
198 {
199 p = (*L)->Union.ptr.hp;
200 q = (*L)->Union.ptr.tp;
201 free(*L);
202 *L = NULL;
203 ClearGList_GL_H_T(&p);
204 ClearGList_GL_H_T(&q);
205 }
206 }
207 }
208
209 /*════╗
210 ║ 算法5.6║
211 ╚════*/
212 void CopyGList_GL_H_T(GList *T, GList L)
213 {
214 if(!L)
215 *T = NULL;
216 else
217 {
218 *T = (GList)malloc(sizeof(GLNode)); //建表结点
219 if(!*T)
220 exit(OVERFLOW);
221
222 (*T)->tag = L->tag;
223
224 if(L->tag==Atom) //复制单原子
225 (*T)->Union.atom = L->Union.atom;
226 else //复制表头和表尾
227 {
228 CopyGList_GL_H_T(&((*T)->Union.ptr.hp), L->Union.ptr.hp);
229 CopyGList_GL_H_T(&((*T)->Union.ptr.tp), L->Union.ptr.tp);
230 }
231 }
232 }
233
234 int GListLength_GL_H_T(GList L)
235 {
236 int count;
237
238 for(count=0; L; count++,L=L->Union.ptr.tp)
239 ;
240
241 return count;
242 }
243
244 /*════╗
245 ║ 算法5.5║
246 ╚════*/
247 int GListDepth_GL_H_T(GList L)
248 {
249 int max, deep;
250 GList p;
251
252 if(!L) //空表深度为1
253 return 1;
254
255 if(L->tag==Atom) //原子深度为0
256 return 0;
257
258 for(max=0,p=L; p; p=p->Union.ptr.tp)
259 {
260 deep = GListDepth_GL_H_T(p->Union.ptr.hp);
261 if(deep>max)
262 max = deep;
263 }
264
265 return max + 1; //非空表的深度是各元素最大深度加一
266 }
267
268 Status GListEmpty_GL_H_T(GList L)
269 {
270 if(!L)
271 return TRUE;
272 else
273 return FALSE;
274 }
275
276 GList GetHead_GL_H_T(GList L)
277 {
278 GList p;
279
280 if(!L)
281 {
282 printf("广义表为空表，无法获取表头！\n");
283 exit(ERROR);
284 }
285
286 CopyGList_GL_H_T(&p, L->Union.ptr.hp);
287
288 return p;
289 }
290
291 GList GetTail_GL_H_T(GList L)
292 {
293 GList p;
294
295 if(!L)
296 {
297 printf("广义表为空表，无法获取表尾！\n");
298 exit(ERROR);
299 }
300
301 CopyGList_GL_H_T(&p, L->Union.ptr.tp);
302
303 return p;
304 }
305
306 void InsertFirst_GL_H_T(GList *L, GList e)
307 {
308 GList g;
309
310 g = (GList)malloc(sizeof(GLNode));
311 if(!g)
312 exit(OVERFLOW);
313
314 g->tag = 1;
315 g->Union.ptr.hp = e;
316 g->Union.ptr.tp = *L;
317 *L = g;
318 }
319
320 void DeleteFirst_GL_H_T(GList *L, GList *e)
321 {
322 GList p;
323
324 if(!(*L))
325 {
326 printf("广义表为空表，删除表头失败！\n");
327 exit(ERROR);
328 }
329
330 p = *L;
331 *L = (*L)->Union.ptr.tp;
332
333 CopyGList_GL_H_T(e, p->Union.ptr.hp);
334
335 free(p);
336 p = NULL;
337 }
338
339 void Traverse_GL_H_T(GList L, void(Visit)(AtomType))
340 {
341 if(L)
342 {
343 if(L->tag==Atom)
344 Visit(L->Union.atom);
345 else
346 {
347 Traverse_GL_H_T(L->Union.ptr.hp, Visit);
348 Traverse_GL_H_T(L->Union.ptr.tp, Visit);
349 }
350 }
351 }
352
353 void Output_GL_H_T(GList L, Mark mark)
354 {
355 if(!L) //L为空
356 {
357 if(mark==Head) //mark=0代表广义表指针来自表头
358 printf("()");
359 else //mark=1代表广义表指针来自表尾
360 printf(")");
361 }
362 else //L不为空时
363 {
364 if(L->tag==Atom) //对于原子结点，输出原子
365 printf("%c",L->Union.atom);
366 else //对于表结点，要对表头、表尾分别讨论
367 {
368 if(mark==Head)
369 printf("(");
370 else
371 printf(",");
372
373 Output_GL_H_T(L->Union.ptr.hp, Head);
374 Output_GL_H_T(L->Union.ptr.tp, Tail);
375 }
376 }
377 }
378
379 #endif
