1. 数据结构C语言单链表的创建,插入删除和合并程序代码
你看这个应该满足要求吧。我把三种循环方式都用上了：
#include<stdio.h>
#include<math.h>
int isprime(int n)
{
int i,t;
if(n==2)
return 1;
if(n%2==0 || n<2)
return 0;
for(i=3,t=(int)sqrt(n);i<=t;i+=2)
{
if(n%i==0)
return 0;
}
return 1;
}
void main()
{
int i,a,n;
i=0;
do
{
printf("Input an integer (>=1):");
scanf("%d",&a);
if(a>=1)
break;
}while(++i<3);
if(i==3) exit(0);
printf("prime submultiples:\n");
i=1;
n=0;
while(i<=a)
{
if(a%i==0)
if(isprime(i))
{
printf("%d ",i);
n++;
if(n%10==0)
printf("\n");
}
i++;
}
2. C语言链式表最少写创建，查询，插入，删除，输出这几个功能 ；完整代码
比你要求的要多很多
看注释
#include"stdio.h"
#include<stdlib.h>
#include"string.h"
typedefintelemType;
/************************************************************************/
/*以下是关于线性表链接存储（单链表）操作的18种算法*/
/*1.初始化线性表，即置单链表的表头指针为空*/
/*2.创建线性表，此函数输入负数终止读取数据*/
/*3.打印链表，链表的遍历*/
/*4.清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表*/
/*5.返回单链表的长度*/
/*6.检查单链表是否为空，若为空则返回1，否则返回0*/
/*7.返回单链表中第pos个结点中的元素，若pos超出范围，则停止程序运行*/
/*8.从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL*/
/*9.把单链表中第pos个结点的值修改为x的值，若修改成功返回1，否则返回0*/
/*10.向单链表的表头插入一个元素*/
/*11.向单链表的末尾添加一个元素*/
/*12.向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回1，否则返回0*/
/*13.向有序单链表中插入元素x结点，使得插入后仍然有序*/
/*14.从单链表中删除表头结点，并把该结点的值返回，若删除失败则停止程序运行*/
/*15.从单链表中删除表尾结点并返回它的值，若删除失败则停止程序运行*/
/*16.从单链表中删除第pos个结点并返回它的值，若删除失败则停止程序运行*/
/*17.从单链表中删除值为x的第一个结点，若删除成功则返回1,否则返回0*/
/*18.交换2个元素的位置*/
/*19.将线性表进行快速排序*/
/************************************************************************/
typedefstructNode{/*定义单链表结点类型*/
elemTypeelement;
structNode*next;
}Node;
/*1.初始化线性表，即置单链表的表头指针为空*/
voidinitList(Node**pNode)
{
*pNode=NULL;
printf("initList函数执行，初始化成功 ");
}
/*2.创建线性表，此函数输入负数终止读取数据*/
Node*creatList(Node*pHead)
{
Node*p1;
Node*p2;
p1=p2=(Node*)malloc(sizeof(Node));//申请新节点
if(p1==NULL||p2==NULL)
{
printf("内存分配失败 ");
exit(0);
}
memset(p1,0,sizeof(Node));
scanf("%d",&p1->element);//输入新节点
p1->next=NULL;//新节点的指针置为空
while(p1->element>0)//输入的值大于0则继续，直到输入的值为负
{
if(pHead==NULL)//空表，接入表头
{
pHead=p1;
}
else
{
p2->next=p1;//非空表，接入表尾
}
p2=p1;
p1=(Node*)malloc(sizeof(Node));//再重申请一个节点
if(p1==NULL||p2==NULL)
{
printf("内存分配失败 ");
exit(0);
}
memset(p1,0,sizeof(Node));
scanf("%d",&p1->element);
p1->next=NULL;
}
printf("creatList函数执行，链表创建成功 ");
returnpHead;//返回链表的头指针
}
/*3.打印链表，链表的遍历*/
voidprintList(Node*pHead)
{
if(NULL==pHead)//链表为空
{
printf("PrintList函数执行，链表为空 ");
}
else
{
while(NULL!=pHead)
{
printf("%d",pHead->element);
pHead=pHead->next;
}
printf(" ");
}
}
/*4.清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表*/
voidclearList(Node*pHead)
{
Node*pNext;//定义一个与pHead相邻节点
if(pHead==NULL)
{
printf("clearList函数执行，链表为空 ");
return;
}
while(pHead->next!=NULL)
{
pNext=pHead->next;//保存下一结点的指针
free(pHead);
pHead=pNext;//表头下移
}
printf("clearList函数执行，链表已经清除 ");
}
/*5.返回单链表的长度*/
intsizeList(Node*pHead)
{
intsize=0;
while(pHead!=NULL)
{
size++;//遍历链表size大小比链表的实际长度小1
pHead=pHead->next;
}
printf("sizeList函数执行，链表长度%d ",size);
returnsize;//链表的实际长度
}
/*6.检查单链表是否为空，若为空则返回1，否则返回0*/
intisEmptyList(Node*pHead)
{
if(pHead==NULL)
{
printf("isEmptyList函数执行，链表为空 ");
return1;
}
printf("isEmptyList函数执行，链表非空 ");
return0;
}
/*7.返回单链表中第pos个结点中的元素，若pos超出范围，则停止程序运行*/
elemTypegetElement(Node*pHead,intpos)
{
inti=0;
if(pos<1)
{
printf("getElement函数执行，pos值非法 ");
return0;
}
if(pHead==NULL)
{
printf("getElement函数执行，链表为空 ");
return0;
//exit(1);
}
while(pHead!=NULL)
{
++i;
if(i==pos)
{
break;
}
pHead=pHead->next;//移到下一结点
}
if(i<pos)//链表长度不足则退出
{
printf("getElement函数执行，pos值超出链表长度 ");
return0;
}
returnpHead->element;
}
/*8.从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL*/
elemType*getElemAddr(Node*pHead,elemTypex)
{
if(NULL==pHead)
{
printf("getElemAddr函数执行，链表为空 ");
returnNULL;
}
if(x<0)
{
printf("getElemAddr函数执行，给定值X不合法 ");
returnNULL;
}
while((pHead->element!=x)&&(NULL!=pHead->next))//判断是否到链表末尾，以及是否存在所要找的元素
{
pHead=pHead->next;
}
if((pHead->element!=x)&&(pHead!=NULL))
{
printf("getElemAddr函数执行，在链表中未找到x值 ");
returnNULL;
}
if(pHead->element==x)
{
printf("getElemAddr函数执行，元素%d的地址为0x%x ",x,&(pHead->element));
}
return&(pHead->element);//返回元素的地址
}
/*9.把单链表中第pos个结点的值修改为x的值，若修改成功返回1，否则返回0*/
intmodifyElem(Node*pNode,intpos,elemTypex)
{
Node*pHead;
pHead=pNode;
inti=0;
if(NULL==pHead)
{
printf("modifyElem函数执行，链表为空 ");
}
if(pos<1)
{
printf("modifyElem函数执行，pos值非法 ");
return0;
}
while(pHead!=NULL)
{
++i;
if(i==pos)
{
break;
}
pHead=pHead->next;//移到下一结点
}
if(i<pos)//链表长度不足则退出
{
printf("modifyElem函数执行，pos值超出链表长度 ");
return0;
}
pNode=pHead;
pNode->element=x;
printf("modifyElem函数执行 ");
return1;
}
/*10.向单链表的表头插入一个元素*/
intinsertHeadList(Node**pNode,elemTypeinsertElem)
{
Node*pInsert;
pInsert=(Node*)malloc(sizeof(Node));
memset(pInsert,0,sizeof(Node));
pInsert->element=insertElem;
pInsert->next=*pNode;
*pNode=pInsert;
printf("insertHeadList函数执行，向表头插入元素成功 ");
return1;
}
/*11.向单链表的末尾添加一个元素*/
intinsertLastList(Node**pNode,elemTypeinsertElem)
{
Node*pInsert;
Node*pHead;
Node*pTmp;//定义一个临时链表用来存放第一个节点
pHead=*pNode;
pTmp=pHead;
pInsert=(Node*)malloc(sizeof(Node));//申请一个新节点
memset(pInsert,0,sizeof(Node));
pInsert->element=insertElem;
while(pHead->next!=NULL)
{
pHead=pHead->next;
}
pHead->next=pInsert;//将链表末尾节点的下一结点指向新添加的节点
*pNode=pTmp;
printf("insertLastList函数执行，向表尾插入元素成功 ");
return1;
}
/*12.向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回1，否则返回0*/
/*13.向有序单链表中插入元素x结点，使得插入后仍然有序*/
/*14.从单链表中删除表头结点，并把该结点的值返回，若删除失败则停止程序运行*/
/*15.从单链表中删除表尾结点并返回它的值，若删除失败则停止程序运行*/
/*16.从单链表中删除第pos个结点并返回它的值，若删除失败则停止程序运行*/
/*17.从单链表中删除值为x的第一个结点，若删除成功则返回1,否则返回0*/
/*18.交换2个元素的位置*/
/*19.将线性表进行快速排序*/
/******************************************************************/
intmain()
{
Node*pList=NULL;
intlength=0;
elemTypeposElem;
initList(&pList);//链表初始化
printList(pList);//遍历链表，打印链表
pList=creatList(pList);//创建链表
printList(pList);
sizeList(pList);//链表的长度
printList(pList);
isEmptyList(pList);//判断链表是否为空链表
posElem=getElement(pList,3);//获取第三个元素，如果元素不足3个，则返回0
printf("getElement函数执行，位置3中的元素为%d ",posElem);
printList(pList);
getElemAddr(pList,5);//获得元素5的地址
modifyElem(pList,4,1);//将链表中位置4上的元素修改为1
printList(pList);
insertHeadList(&pList,5);//表头插入元素12
printList(pList);
insertLastList(&pList,10);//表尾插入元素10
printList(pList);
clearList(pList);//清空链表
system("pause");
}
3. 使用C语言编写程序，实现顺序表的基本运算——插入和删除。
typedef struct
{
int *elem;
int length;
int listsize;
} sqlist;
status Create_sq(Sqlist *L,int n)
{
int i;
L->elem=(int*)malloc(100*sizeof(int));
if(!L->elem) return 0;
for(i=0;i<n;i++)
scanf("%d",&(L->elem[i]));
L->length=n;
L->listsize=100;
return 1;
}
status Listinsert_sq(Sqlist *L,int i,int e)
{
int *q,*p,*newbase;
if(i<1||i>L->length+1) return 0;
if(L->length>=L->listsize)
{
newbase=(int*)realloc(L->elem,(L->listsize+10)*sizeof(int));
if(!newbase) exit(-2);
L->elem=newbase;
L->listsize+=10;
}
q=&(L->elem[i-1]);
for(p=&(L->elem[L->length-1]);p>=q;--p)
*(p+1)=*p;
*q=e;
++L->length;
return 1;
}
int main()
{
Sqlist L1;
int n,a;
int i,e;
printf("\n please input the number of data:\n");
scanf("%d",&n);
if(Create_sq(&L1,n)==1)
{
scanf("%d%d",&i,&e);
a=Listinsert_sq(&L1,i,e);
if(a==1)
printf("insert success\n");
else printf("insert false\n");
printf("the list elements are:\n");
for(i=1;i<=L1.length;i++)
{
printf("%d\t",L1.elem[i-1]);
}
}
return 0;
}
4. C语言线性顺序表的插入和删除
#include"stdio.h"
#include"malloc.h"
#include"iostream.h"
typedef int status;
typedef int elementype;
#define INITSIZE 100
#define INCREMENT 2
struct sqlist
{
elementype *elem;
int length;
int listsize;
};
//建立链表，并排列数据
status listinit(sqlist &l)
{
int i=0,x,j,t;
l.elem=(elementype *)malloc(INITSIZE*sizeof(elementype));
if(!l.elem)
{
cout<<"建表失败"<<endl;
return 0;
}
l.length=0;
l.listsize=INITSIZE;
while(1)
{
cout<<"请输入数据(输入0时结束):";
cin>>x;
if(x==0) break;
l.elem[i]=x;
++l.length;
i++;
}
for(i=0;i<l.length-1;i++)
for(j=0;j<l.length-i-1;j++)
if(l.elem[j]>l.elem[j+1])
{
t=l.elem[j+1];
l.elem[j+1]=l.elem[j];
l.elem[j]=t;
}
cout<<"排序成功"<<endl;
return 1;
}
//插入数据
status listinsert(sqlist &l,int i,elementype e)
{
elementype *p,*q,*newbase;
if(i<1||i>l.length)
{
cout<<"i输入错误"<<endl;
return 0;
}
if(l.length>=l.listsize)
{
newbase=(elementype*)realloc(l.elem,(l.listsize+INCREMENT)*sizeof(elementype));
if(!newbase)
{
cout<<"申请空间失败"<<endl;
return 0;
}
l.elem=newbase;
l.listsize=l.listsize+INCREMENT;
}
q=&(l.elem[i-1]);
for(p=&(l.elem[l.length-1]);p>=q;--p)
{
*(p+1)=*p;
}
*q=e;
++l.length;
cout<<"插入成功";
return 1;
}
//删除数据
status listdelete(sqlist &l,int i,elementype &e)
{
elementype *p,*q;
if(i<1||i>l.length)
{
cout<<"i输入错误"<<endl;
return 0;
}
p=&(l.elem[i-1]);
e=*p;
q=l.elem+l.length-1;
for(++p;p<=q;++p)
{
*(p-1)=*p;
}
--l.length;
cout<<"删除成功"<<endl;
free(&e);
return 1;
}
//删除重复的数据
status listdeleterepeat(sqlist &l)
{
int i,j;
elementype *p,*q,e;
for(i=0;i<l.length-1;i++)
for(j=i+1;j<l.length-1;j++)
if(l.elem[i]==l.elem[j])
{
p=&(l.elem[j]);
e=*p;
q=l.elem+l.length-1;
for(++p;p<=q;++p)
{
*(p-1)=*p;
}
--l.length;
free(&e);
j--;
}
return 1;
}
//输出顺序表数据
status displaylist(sqlist &l)
{
int i;
cout<<"顺序表的数据为:"<<endl;
for(i=0;i<l.length;i++)
{
cout<<l.elem[i]<<" ";
}
cout<<endl;
return 1;
}
//查找数据
status locatelem(sqlist &l,int x)
{
elementype *p;
int i=1;
p=l.elem;
while(i<l.length&&(*p++)!=x)
i++;
cout<<i<<endl;
return 1;
}
//清空列表
void listclear(sqlist &l)
{
l.length=0;
}
//销毁顺序表
void listdestroy(sqlist &l)
{
if(l.elem)
free(l.elem);
}
//求顺序表长度
status listlength(sqlist &l)
{
cout<<"顺序表的长度为:"<<l.length<<endl;
return 1;
}
int main()
{
sqlist l;
int a,i,x;
elementype e;
cout<<"*************************************************"<<endl;
cout<<"* 顺序表的表示和实现 *"<<endl;
cout<<"*************************************************"<<endl;
do{
cout<<"*************************************************"<<endl;
cout<<"* 菜单 *"<<endl;
cout<<"* 1.建立顺序表 *"<<endl;
cout<<"* 2.插入数据 *"<<endl;
cout<<"* 3.删除数据 *"<<endl;
cout<<"* 4.删除重复数据 *"<<endl;
cout<<"* 5.清空数据 *"<<endl;
cout<<"* 6.查找数据 *"<<endl;
cout<<"* 7.顺序表的长度 *"<<endl;
cout<<"* 8.显示顺序表 *"<<endl;
cout<<"* 0.退出顺序表 *"<<endl;
cout<<"*************************************************"<<endl;
cout<<"输入你的选择:";
cin>>a;
switch(a)
{
case 1: listinit(l);
displaylist(l);
break;
case 2: cout<<"请输入要插入数据的位置:";
cin>>i;
cout<<"请输入要插入的数据元素:";
cin>>e;
listinsert(l,i,e);
displaylist(l);
break;
case 3: cout<<"请输入要删除的数据的位置:";
cin>>i;
listdelete(l,i,e);
displaylist(l);
break;
case 4: cout<<"删除前的数据为:";
displaylist(l);
listdeleterepeat(l);
cout<<"删除后的数据为:";
displaylist(l);
break;
case 5: cout<<"清空前为:";
displaylist(l);
cout<<"清空后为:";
listclear(l);
displaylist(l);
break;
case 6: cout<<"输入你要查找的数据:";
cin>>x;
cout<<"你要查找的数据的位置为:";
locatelem(l,x);
displaylist(l);
break;
case 7: cout<<"顺序表的长度为:";
listlength(l);
break;
case 8: displaylist(l);
break;
default: break;
}
}while(a!=0);
return 1;
}