数据结构 一个题目要求用C语言实现 求两个集合的交并补差集的运算 我的源代码有一点

权志龙_爱死你la

数据结构  一个题目要求用C语言实现 求两个集合的交并补差集的运算 我的源代码有一点问题  不能运行出来  我感觉有问题的部分是void readdata_element(element *head)//键盘输入每个集合的元素  这个函数  求大家帮忙看看 谢谢

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #define NULL 0
   
4. typedef struct element//集合元素的结构体
   
5. {
   
6. char data;
   
7. struct element *next;
   
8. }element;
   
9. 
   
10. element init_element(element *head)//初始化集合（集合是用单链表存储结构存储的）
    
11. {
    
12. head=(element*)malloc(sizeof(struct element));
    
13. head->next=NULL;
    
14. return *head;
    
15. }
    
16. void readdata_element(element *head)//键盘输入每个集合的元素
    
17. {
    
18. char c;
    
19. printf("请输入集合中的数据元素（以“F”为结束标志，结束输入）：\n");
    
20. scanf("%c",&c);
    
21. while(c!='F')
    
22. {
    
23. if((c>'a' && c<'z') ||( c>'0' && c<'9'))
    
24. {
    
25. element *p;
    
26. p=(element*)malloc(sizeof(struct element));
    
27. p->data=c;
    
28. p->next=head->next;
    
29. head->next=p;
    
30. scanf("%c",&c);
    
31. }
    
32. else
    
33. printf("输入错误！必须是小写字母或者0~9的数字！请重新输入：\n");
    
34. }
    
35. 
    
36. }
    
37. void display_element(element * head)//输出集合中的所有元素
    
38. {
    
39. element *p;
    
40. p=head->next;
    
41. while(p!=NULL)
    
42. {
    
43. printf("%c",p->data);
    
44. p=p->next;
    
45. }
    
46. printf("\n");
    
47. }
    
48. void bing_element(element *head1,element * head2,element * head3)//求两个集合的并集
    
49. {
    
50. element *p1,*p2,*p3;
    
51. p1=head1->next;
    
52. while(p1!=NULL)
    
53. {
    
54. p3=(element*)malloc(sizeof(struct element));
    
55. p3->data=p1->data;
    
56. p3->next=head3->next;
    
57. head3->next=p3;
    
58. p1=p1->next;
    
59. }
    
60. p2=head2->next;
    
61. while(p2!=NULL)
    
62. {
    
63. p1=head1->next;
    
64. while((p1!=NULL) && (p1->data!=p2->data))
    
65. p1=p1->next;
    
66. if(p1==NULL)
    
67. {
    
68. p3=(element*)malloc(sizeof(struct element));
    
69. p3->data=p2->data;
    
70. p3->next=head3->next;
    
71. head3->next=p3;
    
72. }
    
73. p2=p2->next;
    
74. }
    
75. }
    
76. void jiao_element(element *head1,element *head2,element *head3)//求两个集合的交集
    
77. {
    
78. element *p1,*p2,*p3;
    
79. p1=head1->next;
    
80. while(p1!=NULL)
    
81. {
    
82. p2=head2->next;
    
83. while((p2!=NULL) && (p2->data!=p1->data))
    
84. p2=p2->next;
    
85. if(p2->data==p1->data)
    
86. {
    
87. p3=(element*)malloc(sizeof(struct element));
    
88. p3->data=p1->data;
    
89. p3->next=head3->next;
    
90. head3->next=p3;
    
91. }
    
92. p1=p1->next;
    
93. }
    
94. }
    
95. void cha_element(element *head1,element *head2,element *head3)//求两个集合的差集
    
96. {
    
97. element *p1,*p2,*p3;
    
98. p1=head1->next;
    
99. while(p1!=NULL)
    
100. {
     
101. p2=head2->next;
     
102. while((p2!=NULL) && (p2->data!=p1->data))
     
103. p2=p2->next;
     
104. if(p2==NULL)
     
105. {
     
106. p3=(element*)malloc(sizeof(struct element));
     
107. p3->data=p1->data;
     
108. p3->next=head3->next;
     
109. head3->next=p3;
     
110. }
     
111. p1=p1->next;
     
112. }
     
113. }
     
114. void bu_element(element *head1,element *head2,element *head3)//求集合的补集
     
115. {
     
116. element *p1,*p2,*p3;
     
117. p1=head1->next;
     
118. p2=head2->next;
     
119. while(p1!=NULL)
     
120. {
     
121. while((p2!=NULL) && (p1->data!=p2->data))
     
122. {
     
123. p2=p2->next;
     
124. }
     
125. if(p2==NULL)
     
126. {
     
127. p3->data=p1->data;
     
128. p3->next=head3->next;
     
129. head3->next=p3;
     
130. p3=head3->next;
     
131. }
     
132. p1=p1->next;
     
133. }
     
134. }
     
135. void main()
     
136. {
     
137. element *head1,*head2,*head3,*head4;
     
138. init_element(head1);
     
139. init_element(head2);
     
140. init_element(head3);
     
141. init_element(head4);
     
142. printf("请输入集合1：\n");
     
143. readdata_element(head1);
     
144. 
     
145. printf("请输入集合2：\n");
     
146. readdata_element(head2);
     
147. 
     
148. 
     
149. printf("请输入集合3（全集）：\n");
     
150. readdata_element(head3);
     
151. 
     
152. printf("集合1为：\n");
     
153. display_element(head1);
     
154. printf("集合2为：\n");
     
155. display_element(head2);
     
156. printf("集合3(全集)为：\n");
     
157. display_element(head3);
     
158. char c1;
     
159. printf("运算目录\nA、集合1与集合2的并集\nB、集合1与集合2的交集\nC、集合1与集合2的差集\nD、集合1的补集\nE、集合2的补集\n");
     
160. scanf("%c",&c1);
     
161. if(c1=='A')
     
162. {
     
163. printf("集合1与集合2的并集为：\n");
     
164. bing_element(head1,head2,head4);
     
165. display_element(head4);
     
166. head4->next=NULL;
     
167. }
     
168. if(c1=='B')
     
169. {
     
170. printf("集合1与集合2的交集为：\n");
     
171. bing_element(head1,head2,head4);
     
172. display_element(head4);
     
173. head4->next=NULL;
     
174. }
     
175. if(c1=='C')
     
176. {
     
177. printf("集合1与集合2的差集为：\n");
     
178. bing_element(head1,head2,head4);
     
179. display_element(head4);
     
180. head4->next=NULL;
     
181. }
     
182. if(c1=='D')
     
183. {
     
184. printf("集合1的补集为：\n");
     
185. bing_element(head3,head1,head4);
     
186. display_element(head4);
     
187. head4->next=NULL;
     
188. }
     
189. if(c1=='E')
     
190. {
     
191. printf("集合2的补集为：\n");
     
192. bing_element(head3,head2,head4);
     
193. display_element(head4);
     
194. head4->next=NULL;
     
195. }
     
196. }

复制代码

熊文杰

下面是把交集和补集改过之后的，顺便改成了c风格的 没有用到c++的引用，而是用的二级指针

1. #include <string.h>
   
2. #include<stdio.h>
   
3. #include<stdlib.h>
   
4. #define NULL 0
   
5. typedef struct element//集合元素的结构体
   
6. {
   
7.         char data;
   
8.         struct element *next;
   
9. }element;
   
10. 
    
11. element* init_element(element *head)//初始化集合（集合是用单链表存储结构存储的）
    
12. {
    
13.         head=(element*)malloc(sizeof(struct element));
    
14.         head->next=NULL;
    
15.         return head;
    
16. }
    
17. void readdata_element(element **_head)//键盘输入每个集合的元素
    
18. {
    
19.         static char szBuf[256] = {0};
    
20.         element *head = *_head;
    
21.         
    
22.         printf("请输入集合中的数据元素（以“F”为结束标志，结束输入）：\n");
    
23.         scanf("%s",szBuf);
    
24. 
    
25.         int i = 0;
    
26.         while(szBuf[i] != 'F')
    
27.         {
    
28.                
    
29.                 if((szBuf[i]>='a' && szBuf[i]<='z') ||( szBuf[i]>='0' && szBuf[i]<='9'))
    
30.                 {
    
31.                         element *p;
    
32.                         p=(element*)malloc(sizeof(struct element));
    
33.                         p->data=szBuf[i];
    
34.                         p->next=head->next;
    
35.                         head->next=p;
    
36.                 }
    
37.                 else
    
38.                 {
    
39.                         printf("输入错误！必须是小写字母或者0~9的数字！请重新输入：\n");
    
40.                         break;
    
41.                 }
    
42.                 i++;        
    
43.         }
    
44.         memset(szBuf,0,256);
    
45. }
    
46. 
    
47. 
    
48. void display_element(element *head)//输出集合中的所有元素
    
49. {
    
50.         element *p;
    
51.         p=head->next;
    
52.         while(p!=NULL)
    
53.         {
    
54.                 printf("%c",p->data);
    
55.                 p=p->next;
    
56.         }
    
57.         printf("\n");
    
58. }
    
59. void bing_element(element *head1,element * head2,element * &head3)//求两个集合的并集
    
60. {
    
61.         element *p1,*p2,*p3;
    
62.         p1=head1->next;
    
63.         while(p1!=NULL)
    
64.         {
    
65.                 p3=(element*)malloc(sizeof(struct element));
    
66.                 p3->data=p1->data;
    
67.                 p3->next=head3->next;
    
68.                 head3->next=p3;
    
69.                 p1=p1->next;
    
70.         }
    
71.         p2=head2->next;
    
72.         while(p2!=NULL)
    
73.         {
    
74.                 p1=head1->next;
    
75.                 while((p1!=NULL) && (p1->data!=p2->data))
    
76.                         p1=p1->next;
    
77.                 if(p1==NULL)
    
78.                 {
    
79.                         p3=(element*)malloc(sizeof(struct element));
    
80.                         p3->data=p2->data;
    
81.                         p3->next=head3->next;
    
82.                         head3->next=p3;
    
83.                 }
    
84.                 p2=p2->next;
    
85.         }
    
86. }
    
87. void jiao_element(element *head1,element *head2,element **head3)//求两个集合的交集
    
88. {
    
89.         element *p1,*p2,*p3;
    
90.         p1=head1->next;
    
91.         while(p1!=NULL)
    
92.         {
    
93.                 p2=head2->next;
    
94.                 while((p2!=NULL) && (p2->data!=p1->data))
    
95.                 {
    
96.                         p2=p2->next;
    
97.                 }
    
98.                         
    
99.                 if(p2 != NULL  && p2->data==p1->data)
    
100.                 {
     
101.                         p3=(element*)malloc(sizeof(struct element));
     
102.                         p3->data=p1->data;
     
103.                         p3->next=(*head3)->next;
     
104.                         (*head3)->next=p3;
     
105.                 }
     
106.                 p1=p1->next;
     
107.         }
     
108. }
     
109. void cha_element(element *head1,element *head2,element **head3)//求两个集合的差集
     
110. {
     
111.         element *p1,*p2,*p3;
     
112.         p1=head1->next;
     
113.         while(p1!=NULL)
     
114.         {
     
115.                 p2=head2->next;
     
116.                 while((p2!=NULL) && (p2->data!=p1->data))
     
117.                         p2=p2->next;
     
118.                 if(p2==NULL)
     
119.                 {
     
120.                         p3=(element*)malloc(sizeof(struct element));
     
121.                         p3->data=p1->data;
     
122.                         p3->next=(*head3)->next;
     
123.                         (*head3)->next=p3;
     
124.                 }
     
125.                 p1=p1->next;
     
126.         }
     
127. }
     
128. 
     
129. //第一个参数是全集
     
130. void bu_element(element *head1,element *head2,element **head3)//求集合的补集
     
131. {
     
132.         element *p1,*p2,*p3;
     
133.         p1=head1->next;
     
134.         
     
135.         while(p1!=NULL)
     
136.         {
     
137.                 p2=head2->next;
     
138.                 while((p2!=NULL) && (p1->data!=p2->data))
     
139.                 {
     
140.                         p2=p2->next;
     
141.                 }
     
142.                 if(p2==NULL)
     
143.                 {
     
144.                         p3=(element*)malloc(sizeof(struct element));
     
145.                         p3->data=p1->data;
     
146.                         p3->next=(*head3)->next;
     
147.                         (*head3)->next=p3;
     
148.                 }
     
149.                 p1=p1->next;
     
150.         }
     
151. }
     
152. 
     
153. int main()
     
154. {
     
155.         element *head1,*head2,*head3,*head4;
     
156.         element *p = NULL;
     
157.         head1=init_element(p);
     
158.         head2=init_element(p);
     
159.         head3=init_element(p);
     
160.         head4=init_element(p);
     
161.         printf("请输入集合1：\n");
     
162.         readdata_element(&head1);
     
163. 
     
164.         printf("请输入集合2：\n");
     
165.         readdata_element(&head2);
     
166. 
     
167. 
     
168.         printf("请输入集合3（全集）：\n");
     
169.         readdata_element(&head3);
     
170. 
     
171.         printf("集合1为：\n");
     
172.         display_element(head1);
     
173.         printf("集合2为：\n");
     
174.         display_element(head2);
     
175.         printf("集合3(全集)为：\n");
     
176.         display_element(head3);
     
177.         char c1 ;
     
178.         printf("运算目录\nA、集合1与集合2的并集\nB、集合1与集合2的交集\nC、集合1与集合2的差集\nD、集合1的补集\nE、集合2的补集\n");
     
179. 
     
180.         fflush(stdin);
     
181.         scanf("%c",&c1);
     
182. 
     
183. 
     
184.         if('A' == c1)
     
185.         {
     
186.                 printf("集合1与集合2的并集为：\n");
     
187.                 bing_element(head1,head2,head4);
     
188.                 display_element(head4);
     
189.                 head4->next=NULL;
     
190.         }
     
191.         else if('B' == c1)
     
192.         {
     
193.                 printf("集合1与集合2的交集为：\n");
     
194.                 jiao_element(head1,head2,&head4);
     
195.                 display_element(head4);
     
196.                 head4->next=NULL;
     
197.         }
     
198.         else if('C' == c1)
     
199.         {
     
200.                 printf("集合1与集合2的差集为：\n");
     
201.                 cha_element(head1,head2,&head4);
     
202.                 display_element(head4);
     
203.                 head4->next=NULL;
     
204.         }
     
205.         else if('D' == c1)
     
206.         {
     
207.                 printf("集合1的补集为：\n");
     
208.                 bu_element(head3,head1,&head4);
     
209.                 display_element(head4);
     
210.                 head4->next=NULL;
     
211.         }
     
212.         else if('E' == c1)
     
213.         {
     
214.                 printf("集合2的补集为：\n");
     
215.                 bu_element(head3,head2,&head4);
     
216.                 display_element(head4);
     
217.                 head4->next=NULL;
     
218.         }
     
219.         system("pause");
     
220.         return 0;
     
221. }

复制代码

Skyline

学习学习！！！！！！！！！！！

熊文杰

只帮你改得可以运行，还有一些逻辑上的问题，楼主自己处理一下把

1. #include <string.h>
   
2. #include<stdio.h>
   
3. #include<stdlib.h>
   
4. #define NULL 0
   
5. typedef struct element//集合元素的结构体
   
6. {
   
7.         char data;
   
8.         struct element *next;
   
9. }element;
   
10. 
    
11. element init_element(element *&head)//初始化集合（集合是用单链表存储结构存储的）
    
12. {
    
13.         head=(element*)malloc(sizeof(struct element));
    
14.         head->next=NULL;
    
15.         return *head;
    
16. }
    
17. void readdata_element(element *&head)//键盘输入每个集合的元素
    
18. {
    
19.         static char szBuf[256] = {0};
    
20.        
    
21.         printf("请输入集合中的数据元素（以“F”为结束标志，结束输入）：\n");
    
22.         scanf("%s",szBuf);
    
23. 
    
24.         int i = 0;
    
25.         while(szBuf[i] != 'F')
    
26.         {
    
27.                
    
28.                 if((szBuf[i]>'a' && szBuf[i]<'z') ||( szBuf[i]>'0' && szBuf[i]<'9'))
    
29.                 {
    
30.                         element *p;
    
31.                         p=(element*)malloc(sizeof(struct element));
    
32.                         p->data=szBuf[i];
    
33.                         p->next=head->next;
    
34.                         head->next=p;
    
35.                 }
    
36.                 else
    
37.                 {
    
38.                         printf("输入错误！必须是小写字母或者0~9的数字！请重新输入：\n");
    
39.                         break;
    
40.                 }
    
41.                 i++;       
    
42.         }
    
43.         memset(szBuf,0,256);
    
44. }
    
45. 
    
46. 
    
47. void display_element(element *head)//输出集合中的所有元素
    
48. {
    
49.         element *p;
    
50.         p=head->next;
    
51.         while(p!=NULL)
    
52.         {
    
53.                 printf("%c",p->data);
    
54.                 p=p->next;
    
55.         }
    
56.         printf("\n");
    
57. }
    
58. void bing_element(element *head1,element * head2,element * &head3)//求两个集合的并集
    
59. {
    
60.         element *p1,*p2,*p3;
    
61.         p1=head1->next;
    
62.         while(p1!=NULL)
    
63.         {
    
64.                 p3=(element*)malloc(sizeof(struct element));
    
65.                 p3->data=p1->data;
    
66.                 p3->next=head3->next;
    
67.                 head3->next=p3;
    
68.                 p1=p1->next;
    
69.         }
    
70.         p2=head2->next;
    
71.         while(p2!=NULL)
    
72.         {
    
73.                 p1=head1->next;
    
74.                 while((p1!=NULL) && (p1->data!=p2->data))
    
75.                         p1=p1->next;
    
76.                 if(p1==NULL)
    
77.                 {
    
78.                         p3=(element*)malloc(sizeof(struct element));
    
79.                         p3->data=p2->data;
    
80.                         p3->next=head3->next;
    
81.                         head3->next=p3;
    
82.                 }
    
83.                 p2=p2->next;
    
84.         }
    
85. }
    
86. void jiao_element(element *head1,element *head2,element *&head3)//求两个集合的交集
    
87. {
    
88.         element *p1,*p2,*p3;
    
89.         p1=head1->next;
    
90.         while(p1!=NULL)
    
91.         {
    
92.                 p2=head2->next;
    
93.                 while((p2!=NULL) && (p2->data!=p1->data))
    
94.                         p2=p2->next;
    
95.                 if(p2->data==p1->data)
    
96.                 {
    
97.                         p3=(element*)malloc(sizeof(struct element));
    
98.                         p3->data=p1->data;
    
99.                         p3->next=head3->next;
    
100.                         head3->next=p3;
     
101.                 }
     
102.                 p1=p1->next;
     
103.         }
     
104. }
     
105. void cha_element(element *head1,element *head2,element *&head3)//求两个集合的差集
     
106. {
     
107.         element *p1,*p2,*p3;
     
108.         p1=head1->next;
     
109.         while(p1!=NULL)
     
110.         {
     
111.                 p2=head2->next;
     
112.                 while((p2!=NULL) && (p2->data!=p1->data))
     
113.                         p2=p2->next;
     
114.                 if(p2==NULL)
     
115.                 {
     
116.                         p3=(element*)malloc(sizeof(struct element));
     
117.                         p3->data=p1->data;
     
118.                         p3->next=head3->next;
     
119.                         head3->next=p3;
     
120.                 }
     
121.                 p1=p1->next;
     
122.         }
     
123. }
     
124. void bu_element(element *head1,element *head2,element *&head3)//求集合的补集
     
125. {
     
126.         element *p1,*p2,*p3;
     
127.         p1=head1->next;
     
128.         p2=head2->next;
     
129.         while(p1!=NULL)
     
130.         {
     
131.                 while((p2!=NULL) && (p1->data!=p2->data))
     
132.                 {
     
133.                         p2=p2->next;
     
134.                 }
     
135.                 if(p2==NULL)
     
136.                 {
     
137.                         p3->data=p1->data;
     
138.                         p3->next=head3->next;
     
139.                         head3->next=p3;
     
140.                         p3=head3->next;
     
141.                 }
     
142.                 p1=p1->next;
     
143.         }
     
144. }
     
145. 
     
146. int main()
     
147. {
     
148.         element *head1,*head2,*head3,*head4;
     
149.         init_element(head1);
     
150.         init_element(head2);
     
151.         init_element(head3);
     
152.         init_element(head4);
     
153.         printf("请输入集合1：\n");
     
154.         readdata_element(head1);
     
155. 
     
156.         printf("请输入集合2：\n");
     
157.         readdata_element(head2);
     
158. 
     
159. 
     
160.         printf("请输入集合3（全集）：\n");
     
161.         readdata_element(head3);
     
162. 
     
163.         printf("集合1为：\n");
     
164.         display_element(head1);
     
165.         printf("集合2为：\n");
     
166.         display_element(head2);
     
167.         printf("集合3(全集)为：\n");
     
168.         display_element(head3);
     
169.         char c1 ;
     
170.         printf("运算目录\nA、集合1与集合2的并集\nB、集合1与集合2的交集\nC、集合1与集合2的差集\nD、集合1的补集\nE、集合2的补集\n");
     
171. 
     
172.         fflush(stdin);
     
173.         scanf("%c",&c1);
     
174.        
     
175. 
     
176.         if('A' == c1)
     
177.         {
     
178.                 printf("集合1与集合2的并集为：\n");
     
179.                 bing_element(head1,head2,head4);
     
180.                 display_element(head4);
     
181.                 head4->next=NULL;
     
182.         }
     
183.         else if('B' == c1)
     
184.         {
     
185.                 printf("集合1与集合2的交集为：\n");
     
186.                 bing_element(head1,head2,head4);
     
187.                 display_element(head4);
     
188.                 head4->next=NULL;
     
189.         }
     
190.         else if('C' == c1)
     
191.         {
     
192.                 printf("集合1与集合2的差集为：\n");
     
193.                 bing_element(head1,head2,head4);
     
194.                 display_element(head4);
     
195.                 head4->next=NULL;
     
196.         }
     
197.         else if('D' == c1)
     
198.         {
     
199.                 printf("集合1的补集为：\n");
     
200.                 bing_element(head3,head1,head4);
     
201.                 display_element(head4);
     
202.                 head4->next=NULL;
     
203.         }
     
204.         else if('E' == c1)
     
205.         {
     
206.                 printf("集合2的补集为：\n");
     
207.                 bing_element(head3,head2,head4);
     
208.                 display_element(head4);
     
209.                 head4->next=NULL;
     
210.         }
     
211.         system("pause");
     
212.         return 0;
     
213. }

复制代码

小号4

哇，只知道并查集是怎么搞的，但是不知道交集和补集怎么求

fanki

三楼用了一些c++的语法，正解的，如果c的话把传参的引用& 不要就可以
判断那里应该要加=号吧。
我也看了看~~学习~~这是代码：
void readdata_element(element *head)//键盘输入每个集合的元素
{
        static char szBuf[256] = {0};
        printf( "请输入集合中的数据元素（以“F”为结束标志，结束输入）：\n" );
        scanf( "%s", szBuf );
        int i = 0;
        while( szBuf[i] != 'F' )
        {
                if( ( szBuf[i] >= 'a' && szBuf[i] <= 'z') || ( szBuf[i] >= '0' && szBuf[i] <= '9' ) )
                {
                        element *p;
                        p = ( element* )malloc( sizeof( struct element ) );
                        p->data = szBuf[i];
                        p->next = head->next;
                        head->next = p;
                }
                else
                {
                        //printf("输入错误！必须是小写字母或者0~9的数字！请重新输入：\n");
                        break;
                }
                i++;        
        }
        memset( szBuf, 0, 256 );
}
一起学习，希望对大家有帮助。{:7_155:}支持支持

团鱼之徒

牛逼{:7_155:}

权志龙_爱死你la

熊文杰 发表于 2013-6-22 02:33

                               
登录/注册后可看大图

只帮你改得可以运行，还有一些逻辑上的问题，楼主自己处理一下把

根据你的建议 我将代码改成下面这样 但是不能正确计算补集和交集啊  两个函数看了很多遍 还是不知道是错在函数里 还是主函数里 麻烦你再帮我看一下，谢谢

1. #include <string.h>
   
2. #include<stdio.h>
   
3. #include<stdlib.h>
   
4. #define NULL 0
   
5. typedef struct element//集合元素的结构体
   
6. {
   
7.         char data;
   
8.         struct element *next;
   
9. }element;
   
10. 
    
11. element* init_element()//初始化集合（集合是用单链表存储结构存储的）
    
12. {
    
13.         element *head;
    
14.         head=(element*)malloc(sizeof(struct element));
    
15.         head->next=NULL;
    
16.         return head;
    
17. }
    
18. void readdata_element(element *head)//键盘输入每个集合的元素
    
19. {
    
20.         static char szBuf[256] = {0};
    
21.         printf( "请输入集合中的数据元素：\n" );
    
22.         scanf( "%s", szBuf );
    
23.         int i = 0;
    
24.         while( szBuf[i] != 'F' )
    
25.         {
    
26.                 if( ( szBuf[i] >= 'a' && szBuf[i] <= 'z') || ( szBuf[i] >= '0' && szBuf[i] <= '9' ) )
    
27.                 {
    
28.                         element *p;
    
29.                         p = ( element* )malloc( sizeof( struct element ) );
    
30.                         p->data = szBuf[i];
    
31.                         p->next = head->next;
    
32.                         head->next = p;
    
33.                 }
    
34.                 else
    
35.                 {
    
36.                         //printf("输入错误！必须是小写字母或者0~9的数字！请重新输入：\n");
    
37.                         break;
    
38.                 }
    
39.                 i++;        
    
40.         }
    
41.         memset( szBuf, 0, 256 );
    
42. }
    
43. 
    
44. 
    
45. void display_element(element *head)//输出集合中的所有元素
    
46. {
    
47.         element *p;
    
48.         p=head->next;
    
49.         while(p!=NULL)
    
50.         {
    
51.                 printf("%c",p->data);
    
52.                 p=p->next;
    
53.         }
    
54.         printf("\n");
    
55. }
    
56. void bing_element(element *head1,element * head2,element * &head3)//求两个集合的并集
    
57. {
    
58.         element *p1,*p2,*p3;
    
59.         p1=head1->next;
    
60.         while(p1!=NULL)
    
61.         {
    
62.                 p3=(element*)malloc(sizeof(struct element));
    
63.                 p3->data=p1->data;
    
64.                 p3->next=head3->next;
    
65.                 head3->next=p3;
    
66.                 p1=p1->next;
    
67.         }
    
68.         p2=head2->next;
    
69.         while(p2!=NULL)
    
70.         {
    
71.                 p1=head1->next;
    
72.                 while((p1!=NULL) && (p1->data!=p2->data))
    
73.                         p1=p1->next;
    
74.                 if(p1==NULL)
    
75.                 {
    
76.                         p3=(element*)malloc(sizeof(struct element));
    
77.                         p3->data=p2->data;
    
78.                         p3->next=head3->next;
    
79.                         head3->next=p3;
    
80.                 }
    
81.                 p2=p2->next;
    
82.         }
    
83. }
    
84. void jiao_element(element *head1,element *head2,element *&head3)//求两个集合的交集
    
85. {
    
86.         element *p1,*p2,*p3;
    
87.         p1=head1->next;
    
88.         while(p1!=NULL)
    
89.         {
    
90.                 p2=head2->next;
    
91.                 while((p2!=NULL) && (p2->data!=p1->data))
    
92.                         p2=p2->next;
    
93.                 if(p2->data==p1->data)
    
94.                 {
    
95.                         p3=(element*)malloc(sizeof(struct element));
    
96.                         p3->data=p1->data;
    
97.                         p3->next=head3->next;
    
98.                         head3->next=p3;
    
99.                 }
    
100.                 p1=p1->next;
     
101.         }
     
102. }
     
103. void cha_element(element *head1,element *head2,element *&head3)//求两个集合的差集
     
104. {
     
105.         element *p1,*p2,*p3;
     
106.         p1=head1->next;
     
107.         while(p1!=NULL)
     
108.         {
     
109.                 p2=head2->next;
     
110.                 while((p2!=NULL) && (p2->data!=p1->data))
     
111.                         p2=p2->next;
     
112.                 if(p2==NULL)
     
113.                 {
     
114.                         p3=(element*)malloc(sizeof(struct element));
     
115.                         p3->data=p1->data;
     
116.                         p3->next=head3->next;
     
117.                         head3->next=p3;
     
118.                 }
     
119.                 p1=p1->next;
     
120.         }
     
121. }
     
122. void bu_element(element *head1,element *head2,element *&head3)//求集合的补集(head1是全集)
     
123. {
     
124.         element *p1,*p2,*p3;
     
125.         p1=head1->next;
     
126.         
     
127.         while(p1!=NULL)
     
128.         {
     
129.                        p2=head2->next;
     
130.                
     
131.                            while((p2!=NULL) && (p1->data!=p2->data))
     
132.                 {
     
133.                         p2=p2->next;
     
134.                 }
     
135.                 if(p2==NULL)
     
136.                 {
     
137.                         p3->data=p1->data;
     
138.                         p3->next=head3->next;
     
139.                         head3->next=p3;
     
140.                         p3=head3->next;
     
141.                 }
     
142.                 p1=p1->next;
     
143.         }
     
144. }
     
145. 
     
146. int main()
     
147. {
     
148.         element *head1,*head2,*head3,*head4;
     
149.         head1=init_element();
     
150.         head2=init_element();
     
151.         head3=init_element();
     
152.         head4=init_element();
     
153.         printf("请输入集合1：\n");
     
154.         readdata_element(head1);
     
155. 
     
156.         printf("请输入集合2：\n");
     
157.         readdata_element(head2);
     
158. 
     
159. 
     
160.         printf("请输入集合3（全集）：\n");
     
161.         readdata_element(head3);
     
162. 
     
163.         printf("集合1为：\n");
     
164.         display_element(head1);
     
165.         printf("集合2为：\n");
     
166.         display_element(head2);
     
167.         printf("集合3(全集)为：\n");
     
168.         display_element(head3);
     
169.         char c1 ;
     
170.         printf("运算目录\nA、集合1与集合2的并集\nB、集合1与集合2的交集\nC、集合1与集合2的差集\nD、集合1的补集\nE、集合2的补集\n");
     
171. 
     
172.         fflush(stdin);
     
173.         scanf("%c",&c1);
     
174.         
     
175. 
     
176.         if('A' == c1)
     
177.         {
     
178.                 printf("集合1与集合2的并集为：\n");
     
179.                 bing_element(head1,head2,head4);
     
180.                 display_element(head4);
     
181.                 head4->next=NULL;
     
182.         }
     
183.         else if('B' == c1)
     
184.         {
     
185.                 printf("集合1与集合2的交集为：\n");
     
186.                 jiao_element(head1,head2,head4);
     
187.                 display_element(head4);
     
188.                 head4->next=NULL;
     
189.         }
     
190.         else if('C' == c1)
     
191.         {
     
192.                 printf("集合1与集合2的差集为：\n");
     
193.                 cha_element(head1,head2,head4);
     
194.                 display_element(head4);
     
195.                 head4->next=NULL;
     
196.         }
     
197.         else if('D' == c1)
     
198.         {
     
199.                 printf("集合1的补集为：\n");
     
200.                 bu_element(head3,head1,head4);
     
201.                 display_element(head4);
     
202.                 head4->next=NULL;
     
203.         }
     
204.         else if('E' == c1)
     
205.         {
     
206.                 printf("集合2的补集为：\n");
     
207.                 bu_element(head3,head2,head4);
     
208.                 display_element(head4);
     
209.                 head4->next=NULL;
     
210.         }
     
211.         system("pause");
     
212.         return 0;
     
213. }

复制代码

权志龙_爱死你la

fanki 发表于 2013-6-22 11:55

                               
登录/注册后可看大图

三楼用了一些c++的语法，正解的，如果c的话把传参的引用& 不要就可以
判断那里应该要加=号吧。
我也看了看 ...

根据你们的建议 我将代码改成下面这个样子 但是不能正确计算出交集和补集  我看了很多遍 不知道是函数的问题还是在主函数里出了问题 麻烦 你再帮我看一下好吗，谢谢

1. 根据你的建议 我将代码改成下面这样 但是不能正确计算补集和交集啊  两个函数看了很多遍 还是不知道是错在函数里 还是主函数里 麻烦你再帮我看一下，谢谢
   
2. #include <string.h>
   
3. #include<stdio.h>
   
4. #include<stdlib.h>
   
5. #define NULL 0
   
6. typedef struct element//集合元素的结构体
   
7. {
   
8.         char data;
   
9.         struct element *next;
   
10. }element;
    
11. 
    
12. element* init_element()//初始化集合（集合是用单链表存储结构存储的）
    
13. {
    
14.         element *head;
    
15.         head=(element*)malloc(sizeof(struct element));
    
16.         head->next=NULL;
    
17.         return head;
    
18. }
    
19. void readdata_element(element *head)//键盘输入每个集合的元素
    
20. {
    
21.         static char szBuf[256] = {0};
    
22.         printf( "请输入集合中的数据元素：\n" );
    
23.         scanf( "%s", szBuf );
    
24.         int i = 0;
    
25.         while( szBuf[i] != 'F' )
    
26.         {
    
27.                 if( ( szBuf[i] >= 'a' && szBuf[i] <= 'z') || ( szBuf[i] >= '0' && szBuf[i] <= '9' ) )
    
28.                 {
    
29.                         element *p;
    
30.                         p = ( element* )malloc( sizeof( struct element ) );
    
31.                         p->data = szBuf[i];
    
32.                         p->next = head->next;
    
33.                         head->next = p;
    
34.                 }
    
35.                 else
    
36.                 {
    
37.                         //printf("输入错误！必须是小写字母或者0~9的数字！请重新输入：\n");
    
38.                         break;
    
39.                 }
    
40.                 i++;        
    
41.         }
    
42.         memset( szBuf, 0, 256 );
    
43. }
    
44. 
    
45. 
    
46. void display_element(element *head)//输出集合中的所有元素
    
47. {
    
48.         element *p;
    
49.         p=head->next;
    
50.         while(p!=NULL)
    
51.         {
    
52.                 printf("%c",p->data);
    
53.                 p=p->next;
    
54.         }
    
55.         printf("\n");
    
56. }
    
57. void bing_element(element *head1,element * head2,element * &head3)//求两个集合的并集
    
58. {
    
59.         element *p1,*p2,*p3;
    
60.         p1=head1->next;
    
61.         while(p1!=NULL)
    
62.         {
    
63.                 p3=(element*)malloc(sizeof(struct element));
    
64.                 p3->data=p1->data;
    
65.                 p3->next=head3->next;
    
66.                 head3->next=p3;
    
67.                 p1=p1->next;
    
68.         }
    
69.         p2=head2->next;
    
70.         while(p2!=NULL)
    
71.         {
    
72.                 p1=head1->next;
    
73.                 while((p1!=NULL) && (p1->data!=p2->data))
    
74.                         p1=p1->next;
    
75.                 if(p1==NULL)
    
76.                 {
    
77.                         p3=(element*)malloc(sizeof(struct element));
    
78.                         p3->data=p2->data;
    
79.                         p3->next=head3->next;
    
80.                         head3->next=p3;
    
81.                 }
    
82.                 p2=p2->next;
    
83.         }
    
84. }
    
85. void jiao_element(element *head1,element *head2,element *&head3)//求两个集合的交集
    
86. {
    
87.         element *p1,*p2,*p3;
    
88.         p1=head1->next;
    
89.         while(p1!=NULL)
    
90.         {
    
91.                 p2=head2->next;
    
92.                 while((p2!=NULL) && (p2->data!=p1->data))
    
93.                         p2=p2->next;
    
94.                 if(p2->data==p1->data)
    
95.                 {
    
96.                         p3=(element*)malloc(sizeof(struct element));
    
97.                         p3->data=p1->data;
    
98.                         p3->next=head3->next;
    
99.                         head3->next=p3;
    
100.                 }
     
101.                 p1=p1->next;
     
102.         }
     
103. }
     
104. void cha_element(element *head1,element *head2,element *&head3)//求两个集合的差集
     
105. {
     
106.         element *p1,*p2,*p3;
     
107.         p1=head1->next;
     
108.         while(p1!=NULL)
     
109.         {
     
110.                 p2=head2->next;
     
111.                 while((p2!=NULL) && (p2->data!=p1->data))
     
112.                         p2=p2->next;
     
113.                 if(p2==NULL)
     
114.                 {
     
115.                         p3=(element*)malloc(sizeof(struct element));
     
116.                         p3->data=p1->data;
     
117.                         p3->next=head3->next;
     
118.                         head3->next=p3;
     
119.                 }
     
120.                 p1=p1->next;
     
121.         }
     
122. }
     
123. void bu_element(element *head1,element *head2,element *&head3)//求集合的补集(head1是全集)
     
124. {
     
125.         element *p1,*p2,*p3;
     
126.         p1=head1->next;
     
127.         
     
128.         while(p1!=NULL)
     
129.         {
     
130.                        p2=head2->next;
     
131.                
     
132.                            while((p2!=NULL) && (p1->data!=p2->data))
     
133.                 {
     
134.                         p2=p2->next;
     
135.                 }
     
136.                 if(p2==NULL)
     
137.                 {
     
138.                         p3->data=p1->data;
     
139.                         p3->next=head3->next;
     
140.                         head3->next=p3;
     
141.                         p3=head3->next;
     
142.                 }
     
143.                 p1=p1->next;
     
144.         }
     
145. }
     
146. 
     
147. int main()
     
148. {
     
149.         element *head1,*head2,*head3,*head4;
     
150.         head1=init_element();
     
151.         head2=init_element();
     
152.         head3=init_element();
     
153.         head4=init_element();
     
154.         printf("请输入集合1：\n");
     
155.         readdata_element(head1);
     
156. 
     
157.         printf("请输入集合2：\n");
     
158.         readdata_element(head2);
     
159. 
     
160. 
     
161.         printf("请输入集合3（全集）：\n");
     
162.         readdata_element(head3);
     
163. 
     
164.         printf("集合1为：\n");
     
165.         display_element(head1);
     
166.         printf("集合2为：\n");
     
167.         display_element(head2);
     
168.         printf("集合3(全集)为：\n");
     
169.         display_element(head3);
     
170.         char c1 ;
     
171.         printf("运算目录\nA、集合1与集合2的并集\nB、集合1与集合2的交集\nC、集合1与集合2的差集\nD、集合1的补集\nE、集合2的补集\n");
     
172. 
     
173.         fflush(stdin);
     
174.         scanf("%c",&c1);
     
175.         
     
176. 
     
177.         if('A' == c1)
     
178.         {
     
179.                 printf("集合1与集合2的并集为：\n");
     
180.                 bing_element(head1,head2,head4);
     
181.                 display_element(head4);
     
182.                 head4->next=NULL;
     
183.         }
     
184.         else if('B' == c1)
     
185.         {
     
186.                 printf("集合1与集合2的交集为：\n");
     
187.                 jiao_element(head1,head2,head4);
     
188.                 display_element(head4);
     
189.                 head4->next=NULL;
     
190.         }
     
191.         else if('C' == c1)
     
192.         {
     
193.                 printf("集合1与集合2的差集为：\n");
     
194.                 cha_element(head1,head2,head4);
     
195.                 display_element(head4);
     
196.                 head4->next=NULL;
     
197.         }
     
198.         else if('D' == c1)
     
199.         {
     
200.                 printf("集合1的补集为：\n");
     
201.                 bu_element(head3,head1,head4);
     
202.                 display_element(head4);
     
203.                 head4->next=NULL;
     
204.         }
     
205.         else if('E' == c1)
     
206.         {
     
207.                 printf("集合2的补集为：\n");
     
208.                 bu_element(head3,head2,head4);
     
209.                 display_element(head4);
     
210.                 head4->next=NULL;
     
211.         }
     
212.         system("pause");
     
213.         return 0;
     
214. }

复制代码

权志龙_爱死你la

fanki 发表于 2013-6-22 11:55

                               
登录/注册后可看大图

三楼用了一些c++的语法，正解的，如果c的话把传参的引用& 不要就可以
判断那里应该要加=号吧。
我也看了看 ...

晚上又琢磨了几个小时  改了一下 现在就剩一个问题了 求交集的时候 集合1的元素个数要是大于集合2的元素个数  就不能执行  只有集合1的元素个数小于集合2的元素个数才能执行  求交集的函数 我隐藏每一行都检查了 就是if这个循环语句的问题 手动也搞了半天 就是不知道这是个啥问题 求帮助（下面是修改后的代码）

1. #include <string.h>
   
2. #include<stdio.h>
   
3. #include<stdlib.h>
   
4. #define NULL 0
   
5. typedef struct element//集合元素的结构体
   
6. {
   
7.         char data;
   
8.         struct element *next;
   
9. }element;
   
10. 
    
11. element* init_element()//初始化集合（集合是用单链表存储结构存储的）
    
12. {
    
13.         element *head;
    
14.         head=(element*)malloc(sizeof(struct element));
    
15.         head->next=NULL;
    
16.         return head;
    
17. }
    
18. void readdata_element(element *head)//键盘输入每个集合的元素
    
19. {
    
20.         static char szBuf[256] = {0};
    
21.         printf( "请输入集合中的数据元素：\n" );
    
22.         scanf( "%s", szBuf );
    
23.         int i = 0;
    
24.         while( szBuf[i] != 'F' )
    
25.         {
    
26.                 if( ( szBuf[i] >= 'a' && szBuf[i] <= 'z') || ( szBuf[i] >= '0' && szBuf[i] <= '9' ) )
    
27.                 {
    
28.                         element *p;
    
29.                         p = ( element* )malloc( sizeof( struct element ) );
    
30.                         p->data = szBuf[i];
    
31.                         p->next = head->next;
    
32.                         head->next = p;
    
33.                 }
    
34.                 else
    
35.                 {
    
36.                         //printf("输入错误！必须是小写字母或者0~9的数字！请重新输入：\n");
    
37.                         break;
    
38.                 }
    
39.                 i++;        
    
40.         }
    
41.         memset( szBuf, 0, 256 );
    
42. }
    
43. 
    
44. 
    
45. void display_element(element *head)//输出集合中的所有元素
    
46. {
    
47.         element *p;
    
48.         p=head->next;
    
49.         while(p!=NULL)
    
50.         {
    
51.                 printf("%c",p->data);
    
52.                 p=p->next;
    
53.         }
    
54.         printf("\n");
    
55. }
    
56. void bing_element(element *head1,element * head2,element * &head3)//求两个集合的并集
    
57. {
    
58.         element *p1,*p2,*p3;
    
59.         p1=head1->next;
    
60.         while(p1!=NULL)
    
61.         {
    
62.                 p3=(element*)malloc(sizeof(struct element));
    
63.                 p3->data=p1->data;
    
64.                 p3->next=head3->next;
    
65.                 head3->next=p3;
    
66.                 p1=p1->next;
    
67.         }
    
68.         p2=head2->next;
    
69.         while(p2!=NULL)
    
70.         {
    
71.                 p1=head1->next;
    
72.                 while((p1!=NULL) && (p1->data!=p2->data))
    
73.                         p1=p1->next;
    
74.                 if(p1==NULL)
    
75.                 {
    
76.                         p3=(element*)malloc(sizeof(struct element));
    
77.                         p3->data=p2->data;
    
78.                         p3->next=head3->next;
    
79.                         head3->next=p3;
    
80.                 }
    
81.                 p2=p2->next;
    
82.         }
    
83. }
    
84. void jiao_element(element *head1,element *head2,element *head3)//求两个集合的交集
    
85. {
    
86.         element *p1,*p2,*p3;
    
87.         p1=head1;
    
88.         while(p1!=NULL)
    
89.         {
    
90.                 p2=head2;
    
91.                 while((p2!=NULL) && (p2->data!=p1->data))
    
92.                         p2=p2->next;
    
93.                 if((p2->data)==(p1->data))
    
94.                 {
    
95.                         p3=(element*)malloc(sizeof(struct element));
    
96.                         p3->data=p1->data;
    
97.                         p3->next=head3->next;
    
98.                         head3->next=p3;
    
99.                         display_element(head3);
    
100.                                                
     
101.                                                
     
102.                                                
     
103.                 }
     
104.                 p1=p1->next;
     
105.         }
     
106.                
     
107. }
     
108. void cha_element(element *head1,element *head2,element *&head3)//求两个集合的差集
     
109. {
     
110.         element *p1,*p2,*p3;
     
111.         p1=head1->next;
     
112.         while(p1!=NULL)
     
113.         {
     
114.                 p2=head2->next;
     
115.                 while((p2!=NULL) && (p2->data!=p1->data))
     
116.                         p2=p2->next;
     
117.                 if(p2==NULL)
     
118.                 {
     
119.                         p3=(element*)malloc(sizeof(struct element));
     
120.                         p3->data=p1->data;
     
121.                         p3->next=head3->next;
     
122.                         head3->next=p3;
     
123.                 }
     
124.                 p1=p1->next;
     
125.         }
     
126. }
     
127. void bu_element(element *head1,element *head2,element *head3)//求集合的补集(head1是全集)
     
128. {
     
129.         element *p1,*p2,*p3;
     
130.         p1=head1->next;
     
131.                
     
132.         
     
133.         while(p1!=NULL)
     
134.         {
     
135.                        p2=head2->next;
     
136.                
     
137.                            while((p2!=NULL) && (p1->data!=p2->data))
     
138.                {
     
139.                        p2=p2->next;
     
140.                 }
     
141.                 if(p2==NULL)
     
142.                 {
     
143.                     p3=(element*)malloc(sizeof(struct element));   
     
144.                                         p3->data=p1->data;
     
145.                         p3->next=head3->next;
     
146.                         head3->next=p3;
     
147.                         p3=head3->next;
     
148.                 }
     
149.                 p1=p1->next;
     
150.         }
     
151. }
     
152. 
     
153. int main()
     
154. {
     
155.         element *head1,*head2,*head3,*head4;
     
156.         head1=init_element();
     
157.         head2=init_element();
     
158.         head3=init_element();
     
159.         head4=init_element();
     
160.         printf("请输入集合1：\n");
     
161.         readdata_element(head1);
     
162. 
     
163.         printf("请输入集合2：\n");
     
164.         readdata_element(head2);
     
165. 
     
166. 
     
167.         printf("请输入集合3（全集）：\n");
     
168.         readdata_element(head3);
     
169. 
     
170.         printf("集合1为：\n");
     
171.         display_element(head1);
     
172.         printf("集合2为：\n");
     
173.         display_element(head2);
     
174.         printf("集合3(全集)为：\n");
     
175.         display_element(head3);
     
176.         char c1 ;
     
177.         printf("运算目录\nA、集合1与集合2的并集\nB、集合1与集合2的交集\nC、集合1与集合2的差集\nD、集合1的补集\nE、集合2的补集\n");
     
178. 
     
179.         fflush(stdin);
     
180.         scanf("%c",&c1);
     
181.         
     
182. 
     
183.         if('A' == c1)
     
184.         {
     
185.                 printf("集合1与集合2的并集为：\n");
     
186.                 bing_element(head1,head2,head4);
     
187.                 display_element(head4);
     
188.                 head4->next=NULL;
     
189.         }
     
190.         else if('B' == c1)
     
191.         {
     
192.                 printf("集合1与集合2的交集为：\n");
     
193.                 jiao_element(head1,head2,head4);
     
194.                 display_element(head4);
     
195.                 head4->next=NULL;
     
196.         }
     
197.         else if('C' == c1)
     
198.         {
     
199.                 printf("集合1与集合2的差集为：\n");
     
200.                 cha_element(head1,head2,head4);
     
201.                 display_element(head4);
     
202.                 head4->next=NULL;
     
203.         }
     
204.         else if('D' == c1)
     
205.         {
     
206.                 printf("集合1的补集为：\n");
     
207.                 bu_element(head3,head1,head4);
     
208.                 display_element(head4);
     
209.                 head4->next=NULL;
     
210.         }
     
211.         else if('E' == c1)
     
212.         {
     
213.                 printf("集合2的补集为：\n");
     
214.                 bu_element(head3,head2,head4);
     
215.                 display_element(head4);
     
216.                 head4->next=NULL;
     
217.         }
     
218.         system("pause");
     
219.         return 0;
     
220. }

复制代码

权志龙_爱死你la

熊文杰 发表于 2013-6-22 02:33

                               
登录/注册后可看大图

只帮你改得可以运行，还有一些逻辑上的问题，楼主自己处理一下把

晚上又琢磨了几个小时  改了一下 现在就剩一个问题了 求交集的时候 集合1的元素个数要是大于集合2的元素个数  就不能执行  只有集合1的元素个数小于集合2的元素个数才能执行  求交集的函数 我隐藏每一行都检查了 就是if这个循环语句的问题 手动也搞了半天 就是不知道这是个啥问题 求帮助（下面是修改后的代码）

1. #include <string.h>
   
2. #include<stdio.h>
   
3. #include<stdlib.h>
   
4. #define NULL 0
   
5. typedef struct element//集合元素的结构体
   
6. {
   
7.         char data;
   
8.         struct element *next;
   
9. }element;
   
10. 
    
11. element* init_element()//初始化集合（集合是用单链表存储结构存储的）
    
12. {
    
13.         element *head;
    
14.         head=(element*)malloc(sizeof(struct element));
    
15.         head->next=NULL;
    
16.         return head;
    
17. }
    
18. void readdata_element(element *head)//键盘输入每个集合的元素
    
19. {
    
20.         static char szBuf[256] = {0};
    
21.         printf( "请输入集合中的数据元素：\n" );
    
22.         scanf( "%s", szBuf );
    
23.         int i = 0;
    
24.         while( szBuf[i] != 'F' )
    
25.         {
    
26.                 if( ( szBuf[i] >= 'a' && szBuf[i] <= 'z') || ( szBuf[i] >= '0' && szBuf[i] <= '9' ) )
    
27.                 {
    
28.                         element *p;
    
29.                         p = ( element* )malloc( sizeof( struct element ) );
    
30.                         p->data = szBuf[i];
    
31.                         p->next = head->next;
    
32.                         head->next = p;
    
33.                 }
    
34.                 else
    
35.                 {
    
36.                         //printf("输入错误！必须是小写字母或者0~9的数字！请重新输入：\n");
    
37.                         break;
    
38.                 }
    
39.                 i++;        
    
40.         }
    
41.         memset( szBuf, 0, 256 );
    
42. }
    
43. 
    
44. 
    
45. void display_element(element *head)//输出集合中的所有元素
    
46. {
    
47.         element *p;
    
48.         p=head->next;
    
49.         while(p!=NULL)
    
50.         {
    
51.                 printf("%c",p->data);
    
52.                 p=p->next;
    
53.         }
    
54.         printf("\n");
    
55. }
    
56. void bing_element(element *head1,element * head2,element * &head3)//求两个集合的并集
    
57. {
    
58.         element *p1,*p2,*p3;
    
59.         p1=head1->next;
    
60.         while(p1!=NULL)
    
61.         {
    
62.                 p3=(element*)malloc(sizeof(struct element));
    
63.                 p3->data=p1->data;
    
64.                 p3->next=head3->next;
    
65.                 head3->next=p3;
    
66.                 p1=p1->next;
    
67.         }
    
68.         p2=head2->next;
    
69.         while(p2!=NULL)
    
70.         {
    
71.                 p1=head1->next;
    
72.                 while((p1!=NULL) && (p1->data!=p2->data))
    
73.                         p1=p1->next;
    
74.                 if(p1==NULL)
    
75.                 {
    
76.                         p3=(element*)malloc(sizeof(struct element));
    
77.                         p3->data=p2->data;
    
78.                         p3->next=head3->next;
    
79.                         head3->next=p3;
    
80.                 }
    
81.                 p2=p2->next;
    
82.         }
    
83. }
    
84. void jiao_element(element *head1,element *head2,element *head3)//求两个集合的交集
    
85. {
    
86.         element *p1,*p2,*p3;
    
87.         p1=head1;
    
88.         while(p1!=NULL)
    
89.         {
    
90.                 p2=head2;
    
91.                 while((p2!=NULL) && (p2->data!=p1->data))
    
92.                         p2=p2->next;
    
93.                 if((p2->data)==(p1->data))
    
94.                 {
    
95.                         p3=(element*)malloc(sizeof(struct element));
    
96.                         p3->data=p1->data;
    
97.                         p3->next=head3->next;
    
98.                         head3->next=p3;
    
99.                         display_element(head3);
    
100.                                                
     
101.                                                
     
102.                                                
     
103.                 }
     
104.                 p1=p1->next;
     
105.         }
     
106.                
     
107. }
     
108. void cha_element(element *head1,element *head2,element *&head3)//求两个集合的差集
     
109. {
     
110.         element *p1,*p2,*p3;
     
111.         p1=head1->next;
     
112.         while(p1!=NULL)
     
113.         {
     
114.                 p2=head2->next;
     
115.                 while((p2!=NULL) && (p2->data!=p1->data))
     
116.                         p2=p2->next;
     
117.                 if(p2==NULL)
     
118.                 {
     
119.                         p3=(element*)malloc(sizeof(struct element));
     
120.                         p3->data=p1->data;
     
121.                         p3->next=head3->next;
     
122.                         head3->next=p3;
     
123.                 }
     
124.                 p1=p1->next;
     
125.         }
     
126. }
     
127. void bu_element(element *head1,element *head2,element *head3)//求集合的补集(head1是全集)
     
128. {
     
129.         element *p1,*p2,*p3;
     
130.         p1=head1->next;
     
131.                
     
132.         
     
133.         while(p1!=NULL)
     
134.         {
     
135.                        p2=head2->next;
     
136.                
     
137.                            while((p2!=NULL) && (p1->data!=p2->data))
     
138.                {
     
139.                        p2=p2->next;
     
140.                 }
     
141.                 if(p2==NULL)
     
142.                 {
     
143.                     p3=(element*)malloc(sizeof(struct element));   
     
144.                                         p3->data=p1->data;
     
145.                         p3->next=head3->next;
     
146.                         head3->next=p3;
     
147.                         p3=head3->next;
     
148.                 }
     
149.                 p1=p1->next;
     
150.         }
     
151. }
     
152. 
     
153. int main()
     
154. {
     
155.         element *head1,*head2,*head3,*head4;
     
156.         head1=init_element();
     
157.         head2=init_element();
     
158.         head3=init_element();
     
159.         head4=init_element();
     
160.         printf("请输入集合1：\n");
     
161.         readdata_element(head1);
     
162. 
     
163.         printf("请输入集合2：\n");
     
164.         readdata_element(head2);
     
165. 
     
166. 
     
167.         printf("请输入集合3（全集）：\n");
     
168.         readdata_element(head3);
     
169. 
     
170.         printf("集合1为：\n");
     
171.         display_element(head1);
     
172.         printf("集合2为：\n");
     
173.         display_element(head2);
     
174.         printf("集合3(全集)为：\n");
     
175.         display_element(head3);
     
176.         char c1 ;
     
177.         printf("运算目录\nA、集合1与集合2的并集\nB、集合1与集合2的交集\nC、集合1与集合2的差集\nD、集合1的补集\nE、集合2的补集\n");
     
178. 
     
179.         fflush(stdin);
     
180.         scanf("%c",&c1);
     
181.         
     
182. 
     
183.         if('A' == c1)
     
184.         {
     
185.                 printf("集合1与集合2的并集为：\n");
     
186.                 bing_element(head1,head2,head4);
     
187.                 display_element(head4);
     
188.                 head4->next=NULL;
     
189.         }
     
190.         else if('B' == c1)
     
191.         {
     
192.                 printf("集合1与集合2的交集为：\n");
     
193.                 jiao_element(head1,head2,head4);
     
194.                 display_element(head4);
     
195.                 head4->next=NULL;
     
196.         }
     
197.         else if('C' == c1)
     
198.         {
     
199.                 printf("集合1与集合2的差集为：\n");
     
200.                 cha_element(head1,head2,head4);
     
201.                 display_element(head4);
     
202.                 head4->next=NULL;
     
203.         }
     
204.         else if('D' == c1)
     
205.         {
     
206.                 printf("集合1的补集为：\n");
     
207.                 bu_element(head3,head1,head4);
     
208.                 display_element(head4);
     
209.                 head4->next=NULL;
     
210.         }
     
211.         else if('E' == c1)
     
212.         {
     
213.                 printf("集合2的补集为：\n");
     
214.                 bu_element(head3,head2,head4);
     
215.                 display_element(head4);
     
216.                 head4->next=NULL;
     
217.         }
     
218.         system("pause");
     
219.         return 0;
     
220. }

复制代码

fanki

权志龙_爱死你la 发表于 2013-6-22 22:46

                               
登录/注册后可看大图

晚上又琢磨了几个小时  改了一下 现在就剩一个问题了 求交集的时候 集合1的元素个数要是大于集合2的元素个 ...

昨晚没有上线~~不好意思吖。
如果逻辑没有问题的话，你试试这样。把长的永远放在第一个集合里面放进去做吧。
我改了一下。
加了一个函数：
对比集合一集合二，如果集合一大于集合二不交换，如果不大于的话交换
void exchange( element* head1, element* head2 )
{
        element *p1 = head1;
        element *p2 = head2;
        int x1 = 0, x2 = 0;
        while( p1 == NULL )
        {
                x1++;
                p1 = p1->next;
        }
        while( p2 == NULL )
        {
                x2++;
                p2 = p2->next;
        }
        if ( x1 > x2 ) return;
        else
        {
                p1 = head1;
                head1 = head2;
                head2 = p1;
        }
}


原来判断的代码为：
        else if('B' == c1)
        {
                printf("集合1与集合2的交集为：\n");
                exchange( head1, head2 );
                jiao_element(head1,head2,head4);
                display_element(head4);
                head4->next=NULL;
        }

加一个exchange的判断。
这样做就可以了，这样改比较简单，如果要详细改的话，你可以在jiao_element里边改
原因是因为你只按照集合一大于集合二的方式做，没有考虑集合二大于集合一的考虑。
希望对你有帮助{:7_155:}一起学习学习，加油哦。