（C）顺序表实现集合运算

一、分析算法

　　（1）用数组A，B，C，E表示集合。假定A={1,3，4，5，6，7，9，10},
　　B={2，,3，4，7，8，10}, E={1,2，3，4，5，6，7，8，9，10},
　　输入数组A，B，E（全集），输入数据时要求检查数据是否重复（集合中的数据要求不重复），要求集合A，B是集合E的子集。
　　
　　（2）两个集合的并运算：把数组A中各个元素先保存在数组C中。将数组B中的元素逐一与数组A中的元素进行比较，把不相同的元素添加到数组C中，数组C便是集合A和集合B的并。
　　 C语言算法（线性表顺序结构实现）：

[cpp]  view plain  copy

1. /**求集合的并集的函数**/  
2. void Union_Sq(SqList La,SqList Lb,SqList &Lc){  
3. int i;  
4. ElemType elem;  
5. Lc.length=0;  
6. for(i = 0; i < La.length; i++)  
7. Lc.elem[Lc.length++]=La.elem[i];  
8. for(i = 1; i <= Lb.length; i++){  
9. elem = Lb.elem[i-1];  
10. if(!LocateElem_Sq(La,elem,Equal))  
11. ListInsert_Sq(Lc,Lc.length+1,elem);  
12.    }  
13. }  

（3）两个集合的交运算：把数组A中元素逐一与数组B中的元素进行比较，将相同的元素放在数组C中，数组C便是集合A和集合B的交。
　　c语言算法（线性表顺序结构实现）：

[cpp]  view plain  copy

1. /**求集合的交集的函数**/  
2. void Mix_Sq(SqList La,SqList Lb,SqList &Lc){  
3. int i;  
4. ElemType elem;  
5. Lc.length = 0;  
6. for(i = 1; i <= La.length; i++){  
7. elem = La.elem[i-1];  
8. if(LocateElem_Sq(Lb,elem,Equal))  
9. ListInsert_Sq(Lc,Lc.length+1,elem);  
10.    }  
11. }  

（4）两个集合的差运算：将数组A中的元素逐一与数组B中的元素进行比较，把数组A与数组B不同的元素保存在数组C中，数组C便是集合A和集合B的差A-B。
　　C语言算法（线性表顺序结构实现）：

[cpp]  view plain  copy

1. /**求集合的差集函数**/  
2. void Differ_Sq(SqList La,SqList Lb,SqList &Lc){  
3. int i;  
4. ElemType elem;  
5. Lc.length = 0;  
6. for(i = 1; i <= La.length; i++){  
7. elem = La.elem[i-1];  
8. if(!LocateElem_Sq(Lb,elem,Equal))  
9. ListInsert_Sq(Lc,Lc.length+1,elem);  
10.    }  
11. }  

（5）集合的补运算：将数组E中的元素逐一与数组A中的元素进行比较，把不相同的元素保存到数组C中，数组C便是集合A关于集合E的补集。
　　求补集是一种特殊的集合差运算。
　　 C语言算法（线性表顺序结构实现）：

[cpp]  view plain  copy

1. /**求集合的补集函数**/  
2. void Comple_Sq(SqList La,SqList Lb,SqList &Lc,SqList &Ld){  
3. int i;  
4. ElemType elem;  
5. Ld.length = 0;  
6. Union_Sq(La,Lb,Lc);  
7. for(i = 1; i <= Lc.length; i++){  
8. elem = Lc.elem[i-1];  
9. if(!LocateElem_Sq(La,elem,Equal))  
10. ListInsert_Sq(Ld,Ld.length+1,elem);  
11. }  
12. }  

二.源程序如下：

[cpp]  view plain  copy

1. #include<stdio.h>  
2. #include<stdlib.h>  
3. 
   
4. #define LIST_INIT_SIZE 100 //初始表空间大小  
5. #define LISTINCREMENT 10 //表长增量  
6. 
   
7. 
   
8. /**顺序表的定义**/  
9. typedef struct
10. {  
11. char *elem; /**储存空间基地址**/  
12. int length; /**当前长度**/  
13. int listsize; /**当前分配的储存容量（以sizeof(Elemtype)为单位）**/  
14. }SqList;  
15.    
16. SqList La,Lb,Lc,Ld; /**定义全局变量**/  
17.    
18. /**构造一个空的线性表L**/  
19. int InitList_Sq(SqList &L)
20. {  
21. L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));  
22. if(!L.elem) exit(OVERFLOW); /**储存分配失败**/  
23. L.length = 0; /**空表长度为0**/  
24. L.listsize = LIST_INIT_SIZE; /**初始储存容量**/  
25. return 0;  
26. } /**该函数的时间复杂度为O(n)**/  
27.    
28. /**在顺序表的逻辑为i的位置插入新元素e的函数**/  
29. int ListInsert_Sq(SqList &L,int i,int e)
30. {  
31. char *newbase,*p,*q;  
32. //i的合法值为(1 <= i <= L.length_Sq(L) + 1)  
33. //异常处理  
34. if(i < 1 || i > L.length + 1) return ERROR;  
35. if(L.length >= L.listsize)
36. { //当前储存空间已满，增加分配  
37. newbase = (ElemType *)realloc(L.elem,(L.listsize + LISTINCREMENT) * sizeof(int));  
38. if(!newbase) exit(OVERFLOW); //储存分配失败  
39. L.elem = newbase; //新基址  
40. L.listsize += LISTINCREMENT; //增加储存容量  
41. }  
42. q = &(L.elem[i - 1]); //q为插入位置  
43. for(p = &(L.elem[L.length - 1]); p >= q; --p)   
44. *(p + 1) = *p; //插入位置及之后的元素往右移  
45. *q = e; //插入e  
46. ++L.length; //表长加1  
47. return 0;  
48. }  
49.    
50. /**创建一个线性表，即输入数据,根据集合定义：集合中的元素不能相等创建**/  
51. void CreateList_Sq(SqList &L){  
52. char ch;  
53. int inlist = FALSE,j;  
54. while((ch) != '\n'){  
55. scanf("%c",&ch);  
56. for(j = 0; j < L.length; j++)  
57. if(ch == L.elem[j]){  
58. inlist = TRUE;  
59. break;  
60. }  
61. else  
62. inlist = FALSE;  
63. if(!inlist && ch != '\n') ListInsert_Sq(L,L.length+1,ch);  
64. }  
65. }  
66. /**判断两元素是否相等,若相等则返回TRUE;否则返回FALSE**/  
67. int Equal(int a,int b)
68. {  
69. if(a == b) return TRUE;  
70. else return FALSE;  
71. }  
72.    
73. /**在顺序线性表L中查找第1个与e满足compare()的元素位序，若找到，则返回其在L中的位序，否则返回0**/  
74. int LocateElem_Sq(SqList L,char e,int(* compare)(int,int))
75. {  
76. char *p;  
77. int i;  
78. i = 1; //i的初值为第1个元素的位序  
79. p = L.elem; //p的初值为第1个元素的储存位置  
80. while(i <= L.length && !(* compare)(*p++,e)) ++i;  
81. if(i <= L.length) return i;  
82. else return 0;  
83. } //该函数的时间复杂度为O(n)  
84.    
85. /*销毁线性表的函数*/  
86. int Clear_Sq(SqList &L)
87. {  
88. char elem;  
89. free(L.elem);  
90. L.elem = NULL;  
91. return OK;  
92. }  
93.    
94. /**打印顺序表函数**/  
95. void Print_Sq(SqList L)
96. {  
97. int i;  
98. for(i = 0; i < L.length; i++)  
99. printf("%2c",L.elem[i]);  
100. if(L.length == 0) printf("该集合为空集");   
101. printf(" n = %d\n\n",L.length);  
102. }  
103.    
104. /**求集合的并集的函数**/  
105. void Union_Sq(SqList La,SqList Lb,SqList &Lc)
106. {  
107. int i;  
108. char elem;  
109. Lc.length=0;  
110. for(i = 0; i < La.length; i++)  
111. Lc.elem[Lc.length++]=La.elem[i];  
112. for(i = 1; i <= Lb.length; i++)
113. {  
114. elem = Lb.elem[i-1];  
115. if(!LocateElem_Sq(La,elem,Equal))  
116. ListInsert_Sq(Lc,Lc.length+1,elem);  
117.    }  
118. }  
119.    
120. /**求集合的交集的函数**/  
121. void Mix_Sq(SqList La,SqList Lb,SqList &Lc)
122. {  
123. int i;  
124. char elem;  
125. Lc.length = 0;  
126. for(i = 1; i <= La.length; i++){  
127. elem = La.elem[i-1];  
128. if(LocateElem_Sq(Lb,elem,Equal))  
129. ListInsert_Sq(Lc,Lc.length+1,elem);  
130.    }  
131. }  
132.    
133. /**求集合的差集函数**/  
134. void Differ_Sq(SqList La,SqList Lb,SqList &Lc)
135. {  
136. int i;  
137. char elem;  
138. Lc.length = 0;  
139. for(i = 1; i <= La.length; i++){  
140. elem = La.elem[i-1];  
141. if(!LocateElem_Sq(Lb,elem,Equal))  
142. ListInsert_Sq(Lc,Lc.length+1,elem);  
143.    }  
144. }  
145.    
146. /**求集合的补集函数**/  
147. void Comple_Sq(SqList La,SqList Lb,SqList &Lc,SqList &Ld)
148. {  
149. int i;  
150. char elem;  
151. Ld.length = 0;  
152. Union_Sq(La,Lb,Lc);  
153. for(i = 1; i <= Lc.length; i++)
154. {  
155. elem = Lc.elem[i-1];  
156. if(!LocateElem_Sq(La,elem,Equal))  
157. ListInsert_Sq(Ld,Ld.length+1,elem);  
158. }  
159. }