c语言整数集合的创建

1. c语言如何创建数组

动态数组：void creat(linklist &L)
{
int x;
L=new Lnode;
linklist p,u;
p=L;
cout<<"请输入一些有序的整数,以负数结束："<<endl;
cout<<"请输入一个整数："<<endl;
cin>>x;
while(x>0)
{u=new Lnode;
u->data=x;
p->next=u;
p=p->next;
cin>>x;
}
p->next=NULL;
} 静态数组：int iArray[10]={1，1，2，3，5，8，13，21，34，55)； //初始化
void main()
{
//...
}

2. C语言 从键盘分别输入n(不大于20)和n个元素的整数集合a，m(不大于20)和m个元素的整数集合b，计算并输出集

#include<stdio.h>
int sca_n(int a[])
{
int n,i;
printf("请输入一个整数:\n");
scanf("%d",&n);
printf("请输入%d个祥空整数兆猜:\n",n);
for(i=0;i<n;i++)
scanf("%d",&a[i]);
return n;
}
void prt(int a[],int n)
{
int i;
for(i=0;i<n;i++)
printf("%d ",a[i]);
printf("\n");
}
void sort(int a[],int n)
{
int i,j,temp;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}
}
int intersection (int a[],int n,int b[],int m,int c[])
{
int i,j,k=0,p=0;
for(i=0;i<n;i++)
for(j=0;j<m;j++)
if(a[i]==b[j])c[k++]=a[i];
if(k==0)return 0;
else return k;
}
int Union(int a[],int n,int b[], int m,int c[])
{
int i,j,p,k;
for(i=0;i<n;i++)
c[i]=a[i];
k=n;
for(i=0;i<族宴型m;i++)
{
p=0;
for(j=0;j<n;j++)
if(b[i]!=a[j])p++;
if(p==n)c[k++]=b[i];
}
return k;
}
void main()
{
int a[10],b[10],c[20],n,m,p,q;
n=sca_n(a);
m=sca_n(b);
sort(a,n);sort(b,m);
prt(a,n);prt(b,m);
p=intersection(a,n,b,m,c);
printf("%d\n",p);
prt(c,p);
q=Union(a,n,b,m,c);
printf("%d\n",q);
prt(c,q);
}

3. 用C语言编写一个程序.给出一整数集合,打印出所有的奇数

#include<stdio.h>
#include<malloc.h>

void main()
{ int *p=NULL,n,i;
printf("请世森输入集合中整数个数："御滚); scanf("%d",&n);
p=malloc(n*sizeof(int)); if ( p==NULL ) { printf("申请内存失败！\n”); return; }
printf("请顺序输入这些整数\n");

for ( i=0;i<n;i++ ) scanf("镇返余%d",p+i);
printf("下面输出整数集合中的奇数：\n");

for ( i=0;i<n;i++ ) if ( p[i]%2 ) printf("%d ",p[i]);
printf("\n");
if ( p!=NULL ) free(p);

return;

}

4. c语言里边，怎样先接受一个整数，然后创建一个以这个整数为长度的数组啊

不可以，数组的长度必须是固定的，不能从外边输入一个数来控制数组的长度，用指针也不行，c语言不支持这样的语句，系统会自动检测为错误。如果你定义一个字符常数（＃define A 20），那么这个字符是可以用来定义数组长度的。如int i[A]，这样，你可以通过改变A来改变数组的长度，如改为：＃define A 30；这样数组的长度就由20变为30了。

5. 用c语言编程

程序就是读取文件到数组，再将数组进行排序，最后写入文件。

读写文件流程：fopen获取文件流(根据读写需求，选择参数，使用完必须调用fclose函数关闭)，fscanf读取文件内容，fseek控制文件流指针，fprintf写入文件。

选择排序：每个循环周期选出一个最值，交换一次。

下面是代码（数组为动态数组）：

#include <stdio.h>

#include <malloc.h>

int maxLen;//数组长度

int *read2Nums(char path[]);//读取

int write2File(int *nums,char path[]);//写入

void showNums(int *nums);

int px(int *nums,int flag);//选择排序flag=1升序，flag=0降序

int main()

{

int *nums=NULL;

char rPath[]="c:\000.dat",wPath[]="c:\rank.dat";

if(!(nums=read2Nums(rPath))) return 1;

showNums(nums);

printf("数组升序排列： ");

if(px(nums,1)==-1) return 1;

showNums(nums);

printf("数组降序排列： ");

if(px(nums,0)==-1) return 1;

showNums(nums);

printf("写入到文件路径%s下（存在覆盖，不存在新建） ",wPath);

if(write2File(nums,wPath)==-1) return 1;

printf("写入成功! ");

return 0;

}

void showNums(int *nums)

{

int i;

if(nums) for(i=0,printf("文件内容： ");i<maxLen;printf("%d ",nums[i]),i++);

printf(" ");

}

int px(int *nums,int flag)

{

int i,j,n,temp;

if(!nums) return -1;

for(i=0;i<maxLen-1;i++)

{

n=i;

for(j=i+1;j<maxLen;j++)

{

if(flag && nums[n]>nums[j]) n=j;

if(!flag && nums[n]<nums[j]) n=j;

}

temp=nums[i],nums[i]=nums[n],nums[n]=temp;

}

return 1;

}

int write2File(int *nums,char path[])

{

int i;

FILE *fp=NULL;

if(!nums) return -1;

if(!(fp=fopen(path,"w"))) return -1;

//fseek(fp,SEEK_END);

for(i=0;i<maxLen;i++)

fprintf(fp,"%d ",nums[i]);

fclose(fp);

return 1;

}

int *read2Nums(char path[])

{

int *nums=NULL,*temp=NULL,cnt=0;

FILE *fp=NULL;

maxLen=10;

if(!(fp=fopen(path,"r"))) return NULL;

nums=(int *)malloc(sizeof(int)*maxLen);

if(!nums) return NULL;

while(fscanf(fp,"%d",&nums[cnt++])!=-1)

if(cnt==maxLen)//数组长度不够扩展（每次扩展10长度）

{

maxLen=maxLen+10;

temp=(int *)realloc(nums,sizeof(int)*maxLen);

if(temp) return NULL;

nums=temp;

}

if(--cnt<maxLen)//函数结束前，删除多余地址，减少内存占用

{

maxLen=cnt;

temp=(int *)realloc(nums,sizeof(int)*maxLen);

if(!temp) return NULL;

nums=temp;

}

fclose(fp);

return nums;

}

6. 如何用C++实现一个整数类的集合

这个东西还是用2叉树做吧，链表查找太慢，这是我今天写的，刚好昨天看完了2叉树，所以写了个，试试看，有问题请留言，如果你实在穗隐要用链表实现的话我也可以给你写个：

#include<iostream>
#include<cstddef>
#include<sstream>
usingnamespacestd;

//
template<classT>
classSet;

//binarytreecommonproperties
template<classT>
classBTFolk{
protected:
BTFolk(){};//uncreatable
public:
structNode{
猜派厅Tdata;//data
Node*lhs;//leftchild
Node*rhs;//rightchild
};
staticvoidinorderWalk(constNode*node,std::ostream&os);//traversethetree
staticvoidrecursivelyDelete(Node*node);//cleanuptree
羡蔽staticvoidassign(Set<T>&lhs,constSet<T>&rhs);//assigntoanothertree
};

template<classT>
voidBTFolk<T>::inorderWalk(constNode*node,std::ostream&os)
{
if(node)
{
inorderWalk(node->lhs,os);
os<<node->data<<'';
inorderWalk(node->rhs,os);
}
}

template<classT>
voidBTFolk<T>::recursivelyDelete(Node*node)
{
if(node)
{
recursivelyDelete(node->lhs);
recursivelyDelete(node->rhs);
deletenode;
}
}

template<classT>
voidBTFolk<T>::assign(Set<T>&lhs,constSet<T>&rhs)
{
T*a=rhs.toArray();
lhs.clear();

for(T*beg=a;beg!=a+rhs.size();++beg)
lhs.insert(*beg);
delete[]a;
}

//classSet
template<classT>
classSet:privateBTFolk<T>{
public:

Set();//defaultconstructor
Set(constT*beg,constT*end);//initializefromarray
Set(constSet<T>&rhs);//cc

boolsearch(constT&elem)const;//searchaelement
boolinsert(constT&elem);//insertaelement
boolremove(constT&elem);//deleteaelement
boolempty()const;//issetempty?
voidclear();//cleanup,nullset
T*toArray()const;//converttoasortedarray,remembertoreleasememory

std::size_tsize()const;//returnnumberofelements
friendstd::ostream&operator<<<>(std::ostream&os,constSet<T>&theSet);//outputset
booloperator==(constSet<T>&rhs)const;//testforequality

Set<T>&operator=(constSet<T>&rhs)const;//assign
Set<T>operator*(constSet<T>&rhs)const;//intersection交集
Set<T>operator+(constSet<T>&rhs)const;//union并集
Set<T>operator-(constSet<T>&rhs)const;//difference差集

~Set();
private:
typenameSet<T>::Node*root;//rootnode
std::size_tnumElems;//numberofelements
typenameSet<T>::Node*getParentNode(constT&elem);//getparentnode
};

template<classT>
typenameSet<T>::Node*Set<T>::getParentNode(constT&elem)
{
if(root->data==elem)
return0;

typenameSet<T>::Node*node=elem<root->data?root->lhs:root->rhs;
typenameSet<T>::Node*preNode=root;

while(node->data!=elem)
{
preNode=node;
if(elem<node->data)
node=node->lhs;
else
node=node->rhs;
}
returnpreNode;
}

template<classT>
Set<T>::Set():root(0),numElems(0)
{}

template<classT>
Set<T>::Set(constT*beg,constT*end):root(0),numElems(0)
{
while(beg!=end)
insert(*beg++);
}

template<classT>
Set<T>::Set(constSet<T>&rhs):root(0),numElems(0)
{
assign(*this,rhs);
}

template<classT>
boolSet<T>::search(constT&elem)const
{
typenameSet<T>::Node*node=root;
while(node&&node->data!=elem)
{
if(elem<node->data)
node=node->lhs;
else
node=node->rhs;
}
returnnode?true:false;
}

template<classT>
boolSet<T>::insert(constT&elem)
{
typenameSet<T>::Node**pnode=&root;

if(!search(elem))
{
while(*pnode)
{
if(elem<(*pnode)->data)
pnode=&(*pnode)->lhs;
else
pnode=&(*pnode)->rhs;
}
*pnode=newtypenameSet<T>::Node;
(*pnode)->data=elem;
(*pnode)->lhs=(*pnode)->rhs=0;
++numElems;
returntrue;
}
returnfalse;
}

template<classT>
boolSet<T>::remove(constT&elem)
{
if(!search(elem))
returnfalse;
typenameSet<T>::Node*parent=getParentNode(elem);

typenameSet<T>::Node*temp;
typenameSet<T>::Node**nodeToUpdate;
typenameSet<T>::Node*nodeToRemove;

if(parent)
nodeToUpdate=parent->lhs&&parent->lhs->data==elem?&parent->lhs:&parent->rhs;
else
nodeToUpdate=&root;

nodeToRemove=*nodeToUpdate;

if(!((*nodeToUpdate)->lhs||(*nodeToUpdate)->rhs))
*nodeToUpdate=0;
elseif(((*nodeToUpdate)->lhs?1:0)^((*nodeToUpdate)->rhs?1:0))
*nodeToUpdate=(*nodeToUpdate)->lhs?(*nodeToUpdate)->lhs:(*nodeToUpdate)->rhs;
else
{
temp=(*nodeToUpdate)->rhs;
while(temp->lhs)
temp=temp->lhs;
temp->lhs=(*nodeToUpdate)->lhs;
if(temp->rhs)
getParentNode(temp->data)->lhs=temp->rhs;
temp->rhs=(*nodeToUpdate)->rhs->rhs;
*nodeToUpdate=temp;
}
deletenodeToRemove;
--numElems;
returntrue;
}

template<classT>
inlineboolSet<T>::empty()const
{
returnnumElems==0;
}

template<classT>
inlinevoidSet<T>::clear()
{
recursivelyDelete(root);
root=0;
numElems=0;
}

template<classT>
T*Set<T>::toArray()const
{
stringstreamsstrm;
inorderWalk(root,sstrm);
T*a=newT[numElems];
for(int*p=a;p!=a+numElems;++p)
sstrm>>*p;
returna;
}

template<classT>
inlinestd::size_tSet<T>::size()const
{
returnnumElems;
}

template<classT>
std::ostream&operator<<(std::ostream&os,constSet<T>&theSet)
{
typenameSet<T>::Node*node=theSet.root;
Set<T>::inorderWalk(node,os);
returnos;
}

template<classT>
boolSet<T>::operator==(constSet<T>&rhs)const
{
typenameSet<T>::Node*me=root;
ostringstreamoss1,oss2;

inorderWalk(me,oss1);
inorderWalk(rhs.root,oss2);

returnoss1.str()==oss2.str();
}

template<classT>
Set<T>&Set<T>::operator=(constSet<T>&rhs)const
{
assign(*this,rhs);
return*this;
}

template<classT>
Set<T>Set<T>::operator*(constSet<T>&rhs)const
{
T*a=toArray();
T*bega=a;
T*enda=a+numElems;

Set<T>c;

while(bega!=enda)
{
if(rhs.search(*bega))
c.insert(*bega);
++bega;
}
delete[]a;

returnc;
}

template<classT>
Set<T>Set<T>::operator+(constSet<T>&rhs)const
{
T*a=this->toArray();
T*bega=a;
T*enda=a+this->numElems;
T*b=rhs.toArray();
T*begb=b;
T*endb=b+rhs.numElems;

Set<T>c;
while(bega!=enda)
c.insert(*bega++);
while(begb!=endb)
c.insert(*begb++);

delete[]a;
delete[]b;

returnc;
}

template<classT>
Set<T>Set<T>::operator-(constSet<T>&rhs)const
{
T*a=toArray();
T*bega=a;
T*enda=a+numElems;

Set<T>c;
while(bega!=enda)
{
if(!rhs.search(*bega))
c.insert(*bega);
++bega;
}

delete[]a;

returnc;
}

template<classT>
Set<T>::~Set()
{
recursivelyDelete(root);
}

intmain()
{
intfoo[]={2,6,4,3,4};
Set<int>a,b(foo,foo+5);

a.insert(2);
a.insert(5);
a.insert(1);
a.insert(9);
a.insert(7);

cout<<"seta:"<<a<<"size:"<<a.size()<<'\n';
cout<<"setb:"<<b<<"size:"<<b.size()<<"\n\n";
a.insert(6);
b.insert(1);

cout<<"insert6toa:"<<a<<"size:"<<a.size()<<'\n';
cout<<"insert1tob:"<<b<<"size:"<<b.size()<<"\n\n";

cout<<"trytoinsertplicate9toa:"<<(a.insert(9)?"success\n\n":"failed\n\n");

cout.setf(ios::boolalpha);
cout<<"acontains3:"<<a.search(3)<<'\n';
cout<<"bcontains4:"<<b.search(4)<<"\n\n";

cout<<"delete9froma.\n";
a.remove(9);

intbar[]={1,2,3,4,6};
Set<int>c(bar,bar+5);

cout<<"seta:"<<a<<"size:"<<a.size()<<'\n';
cout<<"setb:"<<b<<"size:"<<b.size()<<'\n';
cout<<"setc:"<<c<<"size:"<<a.size()<<"\n\n";

cout<<"intersectionofa&b:\t"<<a*b<<'\n';
cout<<"unionofa&b:\t\t"<<a+b<<'\n';
cout<<"differenceofa&b:\t"<<a-b<<"\n\n";

cout<<"a==b:"<<(a==b)<<'\n';
cout<<"b==c:"<<(b==c)<<"\n\n";

a.clear();
cout<<"aisempty:"<<a.empty()<<'\n';
cout<<"bisempty:"<<b.empty()<<endl;
cout.unsetf(ios::boolalpha);
}

7. 我要C语言实现创建一个集合（用链表最好），事先并不知道元素个数，请问怎么实现

给你个程序参考一下吧，做实验时哗桥卜编的程序，自己做的，双循环链表，有点多…呵呵

#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

int ff=1;
int dd=1;

typedef int Status;
typedef char Elemtype;

typedef struct Node
{
Elemtype data;
struct Node *prior;
struct Node *next;
}DNode,*DlinkList;

DlinkList L;
DNode b;

Status InitList()
{
b.prior=b.next=&b;L=&b;
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\乱穗t\t完成创建循环双链表，请按回车键返回");
getchar();
dd=0;
return OK;
}

Status ListLength(DNode *L)
{
DlinkList p;
int e=1;
if(dd)
{
return ERROR;
}
p=L->next;
while(p!=L)
{
p=p->next;
e++;
}

return (e);
}

Status ListInsert(DNode *L,int i,Elemtype e)
{
int j;
DlinkList p,s;
p=L;
if(dd)
{
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\t\t请先创建链表，按消搭回车键返回");
getchar();
return ERROR;
}
j=ListLength(L);
if(i<1||i>j)
{
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\t\t所输入元素位置错误，请按回车键返回");
ff=0;
getchar();
return(ERROR);
}
for(j=0;j<i;j++)
p=p->next;
s=(DlinkList)malloc(sizeof(DNode));
if(!s)
return(FALSE);
s->data=e;
s->prior=p->prior;
p->prior->next=s;
s->next=p;
p->prior=s;
ff=1;dd=0;
return(OK);
}

Status InsertNew(DNode *L,char a[])
{
int i;
if(dd)
{
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\t\t请先创建链表，按回车键返回");
getchar();
return ERROR;
}
for(i=1;i<strlen(a)+1;i++)
ListInsert(L,i,a[i-1]);
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\t\t完成插入操作，请按回车键返回");
getchar();
return OK;
}

Status ListEmpty(DNode *L)
{
if(dd)
{
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\t\t请先创建链表，按回车键返回");
getchar();
return ERROR;
}
if(L->next==L->prior)
{
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\t\t该链表为空，请按回车键返回");
getchar();
return OK;
}
else
{
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\t\t该链表非空，请按回车键返回");
getchar();
return FALSE;
}
}

Status GetElem(DNode *L,int i,Elemtype e)
{
int j=0;
DlinkList p;
if(dd)
{
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\t\t请先创建链表，按回车键返回");
getchar();
return ERROR;
}
if(L->next==L->prior)
{
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\t\t该链表为空，请按回车键返回");
getchar();
return ERROR;
}
if(L->next!=L) //双链表不为空表时
{
if(i==1)
{
e=L->next->data;
return 1;
}
else // i不为1时
{
p=L->next;
while((j<i-1)&&(p!=L))
{
j++;
p=p->next;
}
if(p==L)
return 0;
else
{
e=p->data;
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\t\t第%d个元素为%c，请按回车键返回",i,e);
getchar();
return 1;
}
}
}
else //双链表为空表时
return 0;
}

Status LocateElem(DNode *L,Elemtype e)
{
DlinkList p;
int i=1;
system("cls");
if(dd)
{
printf("\n\n\n\n\n\n\n\n\n\t\t\t请先创建链表，按回车键返回");
getchar();
return ERROR;
}
p=L->next;
if(p==L)
{
printf("\n\n\n\n\n\n\n\n\n\t\t\t该链表为空，请按回车键返回");
getchar();
return(0);
}
else
{
while(p->data!=e&&p!=L)
{
p=p->next;
i++;
}
if(p==L)
printf("\n\n\n\n\n\n\n\n\n\t\t\t链表中未找到相应元素，请按回车键返回");
else
printf("\n\n\n\n\n\n\n\n\n\t\t\t该元素为链表中第%d个元素，请按回车键返回",i);
}
getchar();
return OK;
}

Status ListDelete(DNode *L,int i,Elemtype e)
{
int j;
DlinkList p;
int x;
if(dd)
{
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\t\t请先创建链表，按回车键返回");
getchar();
return ERROR;
}
if(L->next==L->prior)
{
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\t\t该链表为空，请按回车键返回");
getchar();
return ERROR;
}
p=L;
j=ListLength(L)-1;
if(i<1||i>j)
{
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\t\t所输入元素位置错误，请按回车键返回");
getchar();
return(ERROR);
}
for(x=0;x<i;x++)
p=p->next;
e=p->data;
p->prior->next=p->next;
p->next->prior=p->prior;
free(p);
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\t\t第%d个元素%c已删除，请按回车键返回",i,e);
getchar();
return(OK);
}

Status DispList(DNode *L)
{
DlinkList p;
int i=1;
Elemtype e;
p=L->next;
system("cls");
if(dd)
{
printf("\n\n\n\n\n\n\n\n\n\t\t\t请先创建链表，按回车键返回");
getchar();
return ERROR;
}
if(p==L)
{
printf("\n\n\n\n\n\n\n\n\n\t\t\t该链表为空，请按回车键返回");
getchar();
return FALSE;
}
while(p!=L)
{
e=p->data;
printf("\n\t第%d个元素为%c",i++,e);
p=p->next;
}
printf("\n\n 请按回车键返回");
getchar();
return OK;
}

Status DestoryList(DNode *L)
{
DlinkList p,q;
if(dd==1)
{
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\t\t链表已被释放，请按回车键返回");
getchar();
return ERROR;
}
q=L->next;
while(q!=L)
{
p=q;
q=p->next;
free(p);
}
L=NULL;
dd=1;
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\t\t完成释放循环双链表，请按回车键返回");
getchar();
return OK;
}

void main()
{
int flag=1;
int l;
char ch,e,a,f;
char m[]="abcde";
while(flag)
{
system("cls");
printf("\n\n\n\n");
printf("\n\t\t\t 0.创建循环双链表");
printf("\n\t\t\t 1.插入新元素a,b,c,d,e");
printf("\n\t\t\t 2.输出循环双链表的长度");
printf("\n\t\t\t 3.判断循环双链表是否为空");
printf("\n\t\t\t 4.输出循环双链表的第三个元素");
printf("\n\t\t\t 5.输出元素a的位置");
printf("\n\t\t\t 6.在第四个元素位置上插入元素f");
printf("\n\t\t\t 7.删除循环双链表的第三个元素");
printf("\n\t\t\t 8.输出循环双链表");
printf("\n\t\t\t 9.释放循环双链表");
printf("\n\t\t\t q.退出");
printf("\n\t\t请选择：");
ch=getchar();getchar();
switch(ch)
{
case'0':InitList();break;
case'1':InsertNew(&b,m);break;
case'2':{
l=ListLength(&b);
system("cls");
if(dd==1)
printf("\n\n\n\n\n\n\n\n\n\t\t\t请先创建链表,按回车键返回");
else
printf("\n\n\n\n\n\n\n\n\n\t\t\t该链表长度为%d，请按回车键返回",l-1);
getchar();break;
}
case'3':ListEmpty(&b);break;
case'4':GetElem(&b,3,e);break;
case'5':LocateElem(&b,'a');break;
case'6':{
ListInsert(&b,4,'f');
if((dd==0)&&(ff==1))
{
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\t\t完成插入操作，请按回车键返回");
getchar();
}
break;
}
case'7':ListDelete(&b,3,e);break;
case'8':DispList(&b);break;
case'9':DestoryList(&b);break;
default:flag=0;
}
}
}

8. C语言实现创建一个集合用链表。事先并不知道元素个数。

有两种方法：用for循环：#include "stdio.h"
#include "malloc.h"
#define NULL 0
#define LEN sizeof(struct data)struct data
{
int num;//假设数据类型为整型,简单的定义一种数据
struct data *next;
};struct data *creat(int n)
{
struct data *p1,*p2,*head;
int i,number;
head=NULL;

for(i=0;i<n;i++)
{
printf("请输入第%d个数据：",i+1);
scanf("%d",&number);
p1=(struct data *)malloc(LEN);
p1->num=number;
p1->next=NULL;
if(head==NULL)
head=p2=p1;
else
{
p2->next=p1;
p2=p1;
}
}
return(head);
}void print(struct data *head)
{
struct data *p;
p=head;
printf("输出数据，它高棚们分别是：\n");
while(p)
{
printf("%d\n",p->num);
p=p->next;
}
return;
}int main(void)
{
struct data *head;
int i;
printf("请输入要输入的数据的数目：");
scanf("%d",&i);
head=creat(i);
print(head);
putchar('\n');
return 0;
} 第二种用while循环：#include "stdio.h"
#include "malloc.h"
#define NULL 0
#define LEN sizeof(struct data)struct data
{
int num;//假设数据类型为整型,简单的定义一种数据
struct data *next;
};int n;struct data *creat(void)
{
struct data *head,*p1,*p2;//建立一个头指针、一个移动指针、一乱蔽个定位指针
int number;
n=0;
printf("请输入第%d个数据：",n+1);
scanf("%d",&number);
head=NULL;
while(number!=0)
{
n++;
p1=(struct data *)malloc(LEN);
p1->num=number;
p1->next=NULL;
if(n==1)
head=p1;
else
p2->next=p1;
p2=p1;
printf("请输入第%d个数据：",n+1);
scanf("%d",&number);
}
return(head);
}void print(struct data *head)
{
struct data *p;
p=head;
printf("现有%d个数据，它们分戚陪则别是：\n",n);
while(p&&p->num)
{
printf("%d\n",p->num);
p=p->next;
}
return;
}int main(void)
{
struct data *head;
head=creat();
print(head);
putchar('\n');
return 0;
}

9. c语言编程，集合

动态规划.

#include<stdio.h>
/*#include<stdlib.h>*/
#include<memory.h>

#defineN5050

intmain(intargc,char*argv)
{
intd[N];
intn,s;
while(scanf("%d",&n)!=EOF){
s=n*(n+1)>>1;
if(s&1){
printf("0
");
}
else{
s=s>>1;
inti,j;
memset(d,0,N*sizeof(d[0]));
d[0]=1;
for(i=1;i<=n;i++){
for(j=s;j>=i;j--){
d[j]=d[j]+d[j-i];
}
}
printf("%d
",d[s]>>1);
}
}
return0;
}

10. 用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); //输出累积者的尾
}
}
}
}