⑴ c语言给定两个集合A和B,,将A-B的元素排序后输出,输入两行,分别为两行,分别为A
#include<stdio.h>
#include<stdlib.h>
intminus(int*a,intm,int*b,intn)
{
inti,j,k;
for(i=0;i<n;i++)
{
for(j=0;j<m;j++)
{
if(a[j]==b[i])
{
for(k=j;k<m-1;k++)
a[k]=a[k+1];
j--;
m--;
}
}
}
returnm;
}
intmain()
{
int*a,*b,m,n,i;
scanf("%d",&m);
a=(int*)malloc(sizeof(int)*m);
for(i=0;i<m;i++)
scanf("%d",a+i);
scanf("%d",&n);
b=(int*)malloc(sizeof(int)*n);
for(i=0;i<n;i++)
scanf("%d",b+i);
m=minus(a,m,b,n);
for(i=0;i<m-1;i++)
printf("%d",a[i]);
printf("%d ",a[i]);
free(a);
free(b);
return0;
}
⑵ 怎样用语言c语言实现集合的合并，交集
通过你描述的问题，正确的交集代码如下：
void
bing(char
a[],char
b[],int
m,int
n)
{
char
d[400];
int
i=0,j=0,s=m;
for(i=0;i<m;i++)
d[i]=a[i];
for(i=0;i<n;i++){
for(j=0;j<m;j++)
{
if(b[i]==a[j])
break;
}
if(j==m)
d[s++]=b[i];
}
cout<<"集合并集是：";
for(i=0;i<s;i++)
cout<<d[i]<<"
";
}
⑶ 用C语言编写集合子集的程序怎么写
首先，你的题目和举例不相符啊。题目是{ 1 ~ n }，而举例是{ 0 ~ n-1}；我以题目为准吧。
如果n=5；其中后面的一部分子集按顺序排是这样的：
{5}
{1 5}
{2 5}
{3 5}
{4 5}
{1 4 5}
{2 4 5}
{3 4 5}
{1 3 4 5}
{2 3 4 5}
{1 2 3 4 5}
我们可以把一个子集看成两个部分，一部分是前面的追赶者，另一部分是后面的累积者。
{1 5}，{2 5}，{3 5}，{4 5}就像这些子集，追赶者从1一直追赶到了4，然后与累积者{5}相遇，累积者变成{4 5}；追赶者从头继续从1一直追赶到了3，然后与累积者{4 5}相遇，累积者变成{3 4 5}；如此反复，可以把这个全部输出来。
而累积者始终是连续的，比如{4 5}、{3 4 5}、{2 3 4 5}，所以我们只用定义累积者的头和尾，就可以把累积者的范围定义。
代码如下，仅供参考：
#include <stdio.h>
void main( void )
{
int n,i,runner,start,end;
printf("请输入正整数n的值：");
scanf("%d",&n);
printf("{}\n"); //空集必定是有的
for(end=1;end<=n;end++) //累积者的尾加一，直到n
{
printf("{%d}\n",end);
for(start=end;start>0;start--) //累积者的头减一，直到1
{
for(runner=1;runner<start;runner++) //追赶者加一，直到遇到累积者的头
{
printf("{");
printf("%d ",runner); //输出追赶者
for(i=start;i<end;i++)
printf("%d ",i); //输出累积者（不包括头，因为累积者的尾后面不跟空格，而是跟}）
printf("%d}\n",end); //输出累积者的尾
}
}
}
}
⑷ c语言 集合a-b
std::set<int> a;std::set<int> b;
std::set<int> c = a-b;
⑸ c语言中字符串"ab"的长度是多少希望高手帮帮忙，谢了！
"ab"的存储为：0x61(a的ASCII),0x62,'\0'(字符串结束符)
但计算长度是，'\0'不计算，它只是结束标志，因此长度是2
⑹ 如何用C语言表示离散数学上的集合,并输出输入
最简单的是bit set（又称为Bit array、bit vector），例如用 typedef unsigned bitset[N / sizeof(unsigned)]表示一个集合（其全集的元素量为N），每个bit代表某个元素是否存在于该集合中。
这个数据结构的好处是，可用位操作（&、|、~）实现并集、交集、补集，非常适合计算机运作。
缺点是空间和时间复杂度和全集的元素数量 N 成正比，而不是集合实际的元素量。例如全集是32位整数，每个集合就需要2^32 bit = 512MB的空间。如果集合中的元素比较少，可以使用有序序列，例如排序数组（Sorted array）、二叉查找树等实现集合。它们的缺点是修改集合不是常数时间。
数据类型关键字
short：修饰int，短整型数据，可省略被修饰的int。（K&R时期引入）
long：修饰int，长整型数据，可省略被修饰的int。（K&R时期引入）
long long：修饰int，超长整型数据，可省略被修饰的int。（C99标准新增）
signed：修饰整型数据，有符号数据类型。（C89标准新增）
unsigned：修饰整型数据，无符号数据类型。（K&R时期引入）
restrict：用于限定和约束指针，并表明指针是访问一个数据对象的初始且唯一的方式。
⑺ 用C语言实现： 已知两个集合A,B（成员为整数），求两个集合的交集，并集，结果存 放于A中，按递增排列。
#include<stdio.h>
#include<malloc.h>
typedefstructnode{
intnum;
structnode*next;
}AGG;
AGG*CreateList(){//创建单循环链表，返回链表头
AGG*head,*p;
inti,n;
printf("结点个数n=");
scanf("%d",&n);
head=p=(AGG*)malloc(sizeof(AGG));//专用头结点
head->num=0;
printf("输入%d整数(空格隔开):
",n);
for(i=0;i<n;++i){
p->next=(AGG*)malloc(sizeof(AGG));
scanf("%d",&p->next->num);
p=p->next;
}
p->next=head;
returnhead;
}
voidRiseSort(AGG*head){//上升排序
AGG*p,*s,*pt;
p=head;
s=p->next;
while(p->next!=head){
while(s->next!=head){
if(p->next->num>s->next->num){
pt=p->next;
p->next=s->next;
s->next=p->next->next;
p->next->next=pt;
}
elses=s->next;
}
p=p->next;
s=p->next;
}
}
voidSimplification(AGG*head){//去除相同的集合元素
AGG*p,*q,*s;
p=head->next;
q=p->next;
while(q!=head){
if(p->num==q->num){
p->next=q->next;
s=q;
q=q->next;
deletes;
}
else{
p=p->next;
q=q->next;
}
}
}
AGG*CreateAgg(){
AGG*head;
head=CreateList();
RiseSort(head);;
Simplification(head);
returnhead;
}
voidInsertNode(AGG*head,intnum){
AGG*t,*p=head;
while(p->next!=head){
if(p->next->num==num)return;
if(p->next->num<num)p=p->next;
else{
t=(AGG*)malloc(sizeof(AGG));
t->num=num;
t->next=p->next;
p->next=t;
return;
}
}
t=(AGG*)malloc(sizeof(AGG));
t->num=num;
p->next=t;
t->next=head;//插入在链表尾的处理
}
AGG*MergeAgg(AGG*A,AGG*B){//A∪B
AGG*head,*pa,*pb,*pc,*qc;
head=pc=(AGG*)malloc(sizeof(AGG));
pa=A->next;
while(pa!=A){
qc=(AGG*)malloc(sizeof(AGG));
qc->num=pa->num;
pc->next=qc;
pc=qc;
pa=pa->next;
}
pc->next=head;
pb=B->next;
while(pb!=B){
InsertNode(head,pb->num);
pb=pb->next;
}
returnhead;
}
AGG*MutualAgg(AGG*A,AGG*B){//A∩B
AGG*C,*pa,*pb,*pc,*qc;
C=pc=(AGG*)malloc(sizeof(AGG));
pc->num=0;
pa=A->next;
pb=B;
while(pa!=A){
pb=B->next;
while(pb!=B){
if(pb->num==pa->num){
qc=(AGG*)malloc(sizeof(AGG));
qc->num=pb->num;
pc->next=qc;
pc=qc;
}
pb=pb->next;
}
pa=pa->next;
}
pc->next=C;
returnC;
}
AGG*DifferAgg(AGG*A,AGG*B){//返回A、B的差集A－B
AGG*head,*p,*q,*r;
inttag;
head=r=(AGG*)malloc(sizeof(AGG));
for(p=A->next;p!=A;p=p->next){
tag=1;
for(q=B->next;q!=B&&tag;q=q->next)
tag=p->num!=q->num;
if(tag){
r->next=(AGG*)malloc(sizeof(AGG));
r=r->next;
r->num=p->num;
}
}
for(p=B->next;p!=B;p=p->next){
tag=1;
for(q=A->next;q!=A&&tag;q=q->next)
tag=p->num!=q->num;
if(tag){
r->next=(AGG*)malloc(sizeof(AGG));
r=r->next;
r->num=p->num;
}
}
r->next=head;
RiseSort(head);
returnhead;
}
voidPrintList(AGG*head){
AGG*p=head->next;
shortcounter=0;
while(p!=head){
if(counter&&counter%10==0)printf("
");
printf("%5d",p->num);
counter++;
p=p->next;
}
if(counter%10)printf("
");
}
voidfreeheap(AGG*head){
AGG*p,*q;
p=head;
q=p->next;
while(q!=head){
p=q;
q=p->next;
free(p);
}
free(head);
}
intmain(){
AGG*A,*B,*C,*D,*E;
printf("创建集合A:
");
A=CreateAgg();
printf("创建集合B:
");
B=CreateAgg();
printf("集合A的元素有:
");
PrintList(A);
printf("集合B的元素有:
");
PrintList(B);
C=MutualAgg(A,B);
printf("交集C=A∩B:
");
PrintList(C);
printf("并集D=A∪B:
");
D=MergeAgg(A,B);
PrintList(D);
printf("差集D=A－B:
");
E=DifferAgg(A,B);
PrintList(E);
freeheap(A);
freeheap(B);
freeheap(C);
freeheap(D);
freeheap(E);
printf("
");
return0;
}
⑻ c语言 中'ab'的值
a的ASCII码是10进制的97，16进制的61，b的ASCII码是10进制的98，16进制的62，顺序写到一起是16进制的6162，转换为10进制就是24930。
'ab'占用2个字节(字面上是这样)，赋给int类型变量在某些编译器(如Dev-C++)中是可能的，但没有推广价值，也米有应用价值，所以这也不会出现在考试、或者笔试题目中。
⑼ 字符串ab在C语言中表示为
"ab" 双引号表示字符串，'a' 单引号表示单个字符