200条c语言代码,c语言代码200行

本文目录一览：

• 1、c语言必背代码有哪些？
• 2、最简单的C语言代码
• 3、编写c语言程序，要求200条以上。。。关于简单的计算器程序。。。急
• 4、请大家给我一些200条以上的C语言程序，谢了！！
• 5、急求啊，写一个200行的C语言程序，什么都可以，带解释，哪位大神帮帮忙

c语言必背代码有哪些？

1、/*输出9*9口诀。共9行9列，i控制行，j控制列。*/

#include “stdio.h”

main()

{int i,j,result;

for (i=1;i10;i++)

{ for(j=1;j10;j++)

{

result=i*j;

printf(“%d*%d=%-3d”,i,j,result);/*-3d表示左对齐，占3位*/

}

printf(“\n”);/*每一行后换行*/

}

}

2、/*古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？

兔子的规律为数列1,1,2,3,5,8,13,21….*/

main()

{

long f1,f2;

int i;

f1=f2=1;

for(i=1;i=20;i++)

{ printf(“%12ld %12ld”,f1,f2);

if(i%2==0) printf(“\n”);/*控制输出，每行四个*/

f1=f1+f2; /*前两个月加起来赋值给第三个月*/

f2=f1+f2; /*前两个月加起来赋值给第三个月*/

}

}

3、/*判断101-200之间有多少个素数，并输出所有素数及素数的个数。

程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，

则表明此数不是素数，反之是素数。*/

#include “math.h”

main()

{

int m,i,k,h=0,leap=1;

printf(“\n”);

for(m=101;m=200;m++)

{ k=sqrt(m+1);

for(i=2;i=k;i++)

if(m%i==0)

{leap=0;break;}

if(leap)    /*内循环结束后，leap依然为1，则m是素数*/

{printf(“%-4d”,m);h++;

if(h%10==0)

printf(“\n”);

}

leap=1;

}

printf(“\nThe total is %d”,h);

}

4、/*一个数如果恰好等于它的因子之和，这个数就称为”完数”。例如6=1＋2＋3.编程

找出1000以内的所有完数。*/

main()

{

static int k[10];

int i,j,n,s;

for(j=2;j1000;j++)

{

n=-1;

s=j;

for(i=1;ij;i++)

{if((j%i)==0)

{  n++;

s=s-i;

k[n]=i;

}

}

if(s==0)

{printf(“%d is a wanshu:  “,j);

for(i=0;in;i++)

printf(“%d,”,k[i]);

printf(“%d\n”,k[n]);

}

}

}

5、/*下面程序的功能是将一个4×4的数组进行逆时针旋转90度后输出，要求原始数组的数据随机输入，新数组以4行4列的方式输出，

请在空白处完善程序。*/

main()

{  int  a[4][4],b[4][4],i,j;       /*a存放原始数组数据，b存放旋转后数组数据*/

printf(“input 16 numbers: “);

/*输入一组数据存放到数组a中，然后旋转存放到b数组中*/

for(i=0;i4;i++)

for(j=0;j4;j++)

{  scanf(“%d”,a[i][j]);

b[3-j][i]=a[i][j];

}

printf(“array b:\n”);

for(i=0;i4;i++)

{  for(j=0;j4;j++)

printf(“%6d”,b[i][j]);

printf(“\n”);

}

}

6、/*编程打印直角杨辉三角形*/

main()

{int i,j,a[6][6];

for(i=0;i=5;i++)

{a[i][i]=1;a[i][0]=1;}

for(i=2;i=5;i++)

for(j=1;j=i-1;j++)

a[i][j]=a[i-1][j]+a[i-1][j-1];

for(i=0;i=5;i++)

{for(j=0;j=i;j++)

printf(“%4d”,a[i][j]);

printf(“\n”);}

}

7、/*通过键盘输入3名学生4门课程的成绩，

分别求每个学生的平均成绩和每门课程的平均成绩。

要求所有成绩均放入一个4行5列的数组中，输入时同一人数据间用空格,不同人用回车

其中最后一列和最后一行分别放每个学生的平均成绩、每门课程的平均成绩及班级总平均分。*/

#include stdio.h

#include stdlib.h

main()

{ float a[4][5],sum1,sum2;

int i,j;

for(i=0;i3;i++)

for(j=0;j4;j++)

scanf(“%f”,a[i][j]);

for(i=0;i3;i++)

{ sum1=0;

for(j=0;j4;j++)

sum1+=a[i][j];

a[i][4]=sum1/4;

}

最简单的C语言代码

最简单的C语言代就是输出“helloWord”，通常是作为初学编程语言时的第一个程序代码。具体代码如下：

#include stdio.h

int main(){

  printf(“Hello, World! \n”);

  return 0;

}

扩展资料：

1、程序的第一行#include stdio.h是预处理器指令，告诉 C 编译器在实际编译之前要包含 stdio.h 文件。

2、下一行intmain（）是主函数，程序从这里开始执行。

3、下一行printf（．．．）是C中另一个可用的函数，会在屏幕上显示消息＂Hello，World！＂。

4、下一行return0；终止main（）函数，并返回值0。

参考资料来源：百度百科-c语言

编写c语言程序，要求200条以上。。。关于简单的计算器程序。。。急

#includestdio.h /*库文件包含*/

#includestring.h /*用于字符串操作*/

#includestdlib.h /*用于exit函数*/

/**************************************************************************

int check(char *c)

输入参数：

char *c: 输入的字符串

返回参数：

0：字符串中有不符合规定的字符

1: 字符串字符符合规定，没有不符合规定的字符.

功能：

检查字符串中有否除了 0-9, +,-,*,/,(,),之外的其他字符，

如果有，则返回0, 表示出现错误。

若没有，则返回1,表式字符串符合规定。

**************************************************************************/

int check(char *c)

{

int k=0;

while(*c!=’\0′)

{

if((*c=’0′ *c=’9′) || *c==’+’ ||

*c==’-‘ || *c==’*’ || *c==’/’ ||

*c==’.’ || *c=='(‘ || *c==’)’ )

{

}

else

{

printf(“input error, there have the char not the math expression char!\n”);

return 0;

}

if(*c=='(‘)

k++;

else if(*c==’)’)

k–;

c++;

}

if(k!=0)

{

printf(“input error, there is not have correct bracket ‘()’!\n”);

return 0;

}

return 1;

}

/**************************************************************************

void move(char *f, double *s,int p)

输入参数：

char *f : 运算符数组

double *s: 数值数组

int p: 当前运算符数组位置。

返回参数:

无

功能：

将当前已经完成运算的运算符消去，同时将数值数组的位置调整以进行下一次运算。

传入值p若为3

则当前符号的数组位置为3.

f[3]=f[3+1]…….f[len-2]=f[len-1] f[len-1]=’\0′;

s[i]=s[i+1]…….s[len-1]=s[len] 因为数值比运算符多一个。

***************************************************************************/

void move(char *f, double *s,int p)

{

int i=0,len=strlen(f);

for(i=p; ilen; i++) /*将已经运算过的符号，空出来的位置用后面的符号来填充，*/

{ /*即把乘和除号的位置用后面的加和减号填充*/

f[i]=f[i+1];

s[i]=s[i+1];

}

s[i]=s[i+1];

f[len-1]=’\0′;

}

/**************************************************************************

double convnum(char *c)

输入参数：

char *c :由数字和小数点组成的字符，用以转换成double型的数值。

返回参数：

num:返回转换好的值。

功能：

将输入的字符串先将其小数点以前的部分复制到temp[]数组中，

若有小数点，则将小数点之后的数值，也就是小数部分先进行计算,值存入num中

计算完成后，再对整数部分进行计算，值加上小数部分的值，存入num中。

***************************************************************************/

double convnum(char *c)

{

double num=0.0;

double a=1.0;

int i=0,p=0,len=0;

char temp[100];

int tempi=0;

int start=0;

int f=1; /*正负符号指示器，若为1则为正数，为－1，此数为负数*/

len=strlen(c);

if(c[0]==’-‘)

{

start=1;

f=-1;

}

for(i=start; ilen; i++)

{

if(c[i]==’.’)

{

p=i;

break;

}

temp[tempi++]=c[i]; /*将整数部分复制到temp[]中*/

}

temp[tempi]=’\0′;

if(p!=0)

{

for(i=p+1;ilen;i++) /*将小数部分计算出来*/

{

if(c[i]==’.’) /*如果有多余的小数点，则表示输入错误*/

{

printf(“there is more that one dot ‘.’ in number!error!\n”);

exit(0);

}

a=a*0.1;

num+=(a*(c[i]-48));

}

}

a=1.0;

len=strlen(temp); /*计算整数部分*/

for(i=len-1;i=0; i–)

{

num=num+(a*(temp[i]-48));

a*=10;

}

num=num*f;

return num;

}

/**************************************************************************

double good(char *c)

输入参数：

char *c :即将进行运算的字符串型数学表达式。如3.5+(2*3/5)

返回参数：

s[0]:计算结果将放入s[0]中

功能：

将输入的字符串中的数字分别调用convnum(char *c)函数进行数值变换，再将其依

次存入doulbe s[i]中，将加减乘除运算符依次存入字符串符号数组 char f[i]中，

然后如果遇到括号，则将括号内的字符串存入另一字符数组中，然后用此

good(char *c) 递归函数进行递归运算。 然后根据先乘除，后加减的顺序对已

存入数组的数值根 据存入字符串符号数组的运算符进行运算。结果存入s[0]中。

返回最终结果。

***************************************************************************/

double good(char *c) /*可递归函数*/

{ /*取得数值字符串，并调用convnum转换成double*/

char g[100],number[30]; /*g,保存当前的表达式串,number保存一个数的所有字符*/

char f[80]; /*保存所有的符号的堆栈*/

int fi=0; /*保存符号的位置指针*/

double s[80]; /*保存当前所有的数的一个堆栈*/

int si=0; /*保存数字位置指针*/

int k=0; /* 若k=1则表示有一对括号*/

int num=0,i=0; /*num保存新括号内的字符数,i 保存number里的字符位置*/

int cc=0; /*乘除符号数量*/

int jj=0; /*加减符号数量*/

while(*c!=’\0′)/*当p==1 和k==0时，表示已经把括号里的内容全部复制到g[100]中了*/

{

k=0;

num=0;

switch(*c)

{

case ‘+’: /*当前字符为+-乘除时则表示*/

case ‘-‘:

case ‘*’:

case’/’:

f[fi++]=*c;

if(*c==’*’ || *c==’/’)

cc++;

else

jj++;

if(*(c-1)!=’)’)

{

number[i]=’\0′;

i=0;/*完成一个数字的复制，其位置指针i=0*/

s[si++]=convnum(number);

}

break;

case'(‘: /*有括号，则将当前括号作用范围内的全部字符保存，作为*/

k++; /*一个新的字符表达式进行递归调用good函数计算。*/

while(k0)

{

c++;

g[num]=*c;

num++;

if(*c==’)’)

{

k–;

}

else if(*c=='(‘)

{

k++;

}

}

g[num-1]=’\0′;

num=0;/*完成一个括号内容的复制，其位置指针num=0*/

s[si++]=good(g);

break;

default:

number[i++]=*c;

if(*(c+1)==’\0′)

{ number[i]=’\0′;

s[si++]=convnum(number);

}

break;

}

c++;

}

f[fi]=’\0′;

i=0;

while(cc0)

{

switch(f[i])

{

case ‘*’: cc–;

s[i+1]=s[i]*s[i+1];

move(f,s,i);

break;

case ‘/’: cc–;

s[i+1]=s[i]/(float)s[i+1];

move(f,s,i);

break;

default:

i++;

break;

}

}

i=0;

while(jj0)

{

switch(f[i])

{

case ‘+’: s[i+1]=s[i]+s[i+1];

jj–;

move(f,s,i);

break;

case ‘-‘: s[i+1]=s[i]-s[i+1];

jj–;

move(f,s,i);

break;

default:

printf(“operator error!”);

break;

}

}

return s[0];

}

void main()

{

char str[100];

double sum=0;

int p=1;

while(1)

{

printf(“enter expression: enter ‘exit’ end of program\n”);

scanf(“%s”,str);

p=strcmp(str,”exit”);

if(p==0)

break;

p=check(str);

if(p==0)

continue;

sum=good(str);

printf(“%s=%f”,str,sum);

printf(“\n”);

}

printf(“good bye!\n”);

}

请大家给我一些200条以上的C语言程序，谢了！！

抄一个大数加减乘除程序给你。218行。

#include stdio.h

#define MAXINT 1000

int compare(int a[],int b[]);

int bigplus(int a[],int b[],int c[]);

int bigsub(int a[],int b[],int c[]);

int bigmult(int a[],unsigned int b,int c[]);

int bigmult2(int a[],int b[],int c[]);

int bigdiv(int a[],unsigned int b,int c[],int *d);

int bigdiv2(int a[],int b[],int c[],int d[]);

int main(int argc, char *argv[])

{

int a[MAXINT]={10,5,4,6,5,4,3,2,1,1,1}; //被乘数或被除数

int b[MAXINT]={7,7,6,5,4,3,2,1}; //乘数或除数

int c[MAXINT],d[MAXINT]; //c[]存放商，d[]存放余数

int div=1234; //小乘数或小除数

int k=0;

int *res=k; //小余数整数指针

bigplus(a,b,c);

bigsub(a,b,c);

bigmult(a,div,c);

bigmult2(a,b,c);

bigdiv(a,div,c,res);

bigdiv2(a,b,c,d);

getchar();

return 0;

}

int compare(int a[],int b[]) //比较大整数的大小

{

int i;

if (a[0]b[0]) return 1; //比较a,b的位数确定返回值

else if (a[0]b[0]) return -1;

else //位数相等时的比较

{

i=a[0];

while (a[i]==b[i]) //逐位比较

i–;

if (i==0) return 0;

else if (a[i]b[i]) return 1;

else return -1;

}

}

int bigplus(int a[],int b[],int c[]) //大整数加法

{

int i,len;

len=(a[0]b[0]?a[0]:b[0]); //a[0] b[0]保存数组长度，len为较长的一个

for(i=0;iMAXINT;i++) //将数组清0

c[i]=0;

for (i=1;i=len;i++) //计算每一位的值

{

c[i]+=(a[i]+b[i]);

if (c[i]=10)

{

c[i]-=10; //大于10的取个位

c[i+1]++; //高位加1

}

}

if (c[i+1]0) len++;

c[0]=len; //c[0]保存结果数组实际长度

printf(“Big integers add: “;

for (i=len;i=1;i–)

printf(“%d”,c[i]); //打印结果

printf(“\n”;

return 0;

}

int bigsub(int a[],int b[],int c[]) //大整数减法

{

int i,len;

len=(a[0]b[0]?a[0]:b[0]); //a[0]保存数字长度，len为较长的一个

for(i=0;iMAXINT;i++) //将数组清0

c[i]=0;

if (compare(a,b)==0) //比较a,b大小

{

printf(“Result:0”;

return 0;

}

else if (compare(a,b)0)

for (i=1;i=len;i++) //计算每一位的值

{

c[i]+=(a[i]-b[i]);

if (c[i]0)

{

c[i]+=10; //小于0的原位加10

c[i+1]–; //高位减1

}

}

else

for (i=1;i=len;i++) //计算每一位的值

{

c[i]+=(b[i]-a[i]);

if (c[i]0)

{

c[i]+=10; //小于0原位加10

c[i+1]–; //高位减1

}

}

while (len1 c[len]==0) //去掉高位的0

len–;

c[0]=len;

printf(“Big integers sub= “;

if (a[0]b[0]) printf(“-“;

for(i=len;i=1;i–) //打印结果

printf(“%d”,c[i]);

printf(“\n”;

return 0;

}

int bigmult(int a[],unsigned int b,int c[])//高精度乘以低精度

{

int len,i;

for (i=0;iMAXINT;i++) //数组清0

c[i]=0;

len=a[0];

for(i=1;i=len;i++) //对每一位计算

{

c[i]+=a[i]*b;

c[i+1]+=c[i]/10;

c[i]%=10;

}

while (c[++len]=10) //处理高位

{

c[len+1]=c[len]/10;

c[len]%=10;

}

if (c[len]==0) len–; //处理高进位为0情况

printf(“Big integrs multi small integer: “;

for (i=len;i=1;i–)

printf(“%d”,c[i]);

printf(“\n”;

}

int bigmult2(int a[],int b[],int c[]) //高精度乘以高精度

{

int i,j,len;

for (i=0;iMAXINT;i++) //数组清0

c[i]=0;

for (i=1;i=a[0];i++) //被乘数循环

for (j=1;j=b[0];j++) //乘数循环

{

c[i+j-1]+=a[i]*b[j]; //将每一位计算累加

c[i+j]+=c[i+j-1]/10; //将每一次结果累加到高一位

c[i+j-1]%=10; //计算每一次的个位

}

len=a[0]+b[0]; //取最大长度

while (len1 c[len]==0) //去掉高位0

len–;

c[0]=len;

printf(“Big integers multi: “;

for (i=len;i=1;i–) //打印结果

printf(“%d”,c[i]);

printf(“\n”;

}

int bigdiv(int a[],unsigned int b,int c[],int *d) //高精度除以低精度

{ //a[] 为被乘数,b为除数,c[]为结果,d为余数

int i,len;

len=a[0]; //len为a[0]的数组长度

for (i=len;i=1;i–)

{

(*d)=10*(*d)+a[i]; //计算每一步余数

c[i]=(*d)/b; //计算每一步结果

(*d)=(*d)%b; //求模余数

}

while (len1 c[len]==0) len–; //去高位0

printf(“Big integer div small integer: “;

for (i=len;i=1;i–) //打印结果

printf(“%d”,c[i]);

printf(“\tArithmetic compliment:%d”,*d);

printf(“\n”;

}

int bigdiv2(int a[],int b[],int c[],int d[]) //高精度除以高精度

{

int i,j,len;

if (compare(a,b)0) //被除数较小直接打印结果

{

printf(“Result:0”;

printf(“Arithmetic compliment:”;

for (i=a[0];i=1;i–) printf(“%d”,a[i]);

printf(“\n”;

return -1;

}

for (i=0;iMAXINT;i++) //商和余数清0

{

c[i]=0;

d[i]=0;

}

len=a[0];d[0]=0;

for (i=len;i=1;i–) //逐位相除

{

for (j=d[0];j=1;j–)

d[j+1]=d[j];

d[1]=a[i]; //高位*10+各位

d[0]++; //数组d长度增1

while (compare(d,b)=0) //比较d,b大小

{

for (j=1;j=d[0];j++) //做减法d-b

{

d[j]-=b[j];

if (d[j]0)

{

d[j]+=10;

d[j+1]–;

}

}

while (j0 d[j]==0) //去掉高位0

j–;

d[0]=j;

c[i]++; //商所在位值加1

}

}

j=b[0];

while (c[j]==0 j0) j–; //求商数组c长度

c[0]=j;

printf(“Big integers div result: “;

for (i=c[0];i=1;i–) //打印商

printf(“%d”,c[i]);

printf(“\tArithmetic compliment: “; //打印余数

for (i=d[0];i=1;i–)

printf(“%d”,d[i]);

printf(“\n”);

}

急求啊，写一个200行的C语言程序，什么都可以，带解释，哪位大神帮帮忙

#include stdio.h

#define OK 1   

#define ERROR 0

#define TRUE 1   

#define FALSE 0

#define MAXSIZE 100

#define LElemType int

#define Status int

#define BOOL int

typedef struct

{

 LElemType data;

 int cur;

}Component,SLinkList[MAXSIZE];

int Malloc(SLinkList space) 

{ 

 //若备用链表非空，则返回分配的结点下标(备用链表的第一个结点)，否则返回0

 int i=space[0].cur;

 if (i)

  space[0].cur=space[i].cur;

 return i;

}

Status Free(SLinkList space, int k) 

{ 

 //将下标为空的空闲结点回收到备用链表(成为备用链表的第一个结点)

 space[k].cur=space[0].cur;

 space[0].cur=k;

 return OK;

}

Status InitList(SLinkList L)

{ 

 //构造一个空的链表L，表头为L的最后一个单元L[MAXSIZE-1]，其余单元链成

 //一个备用链表，表头为L的第一个单元L[0]，“0”表示空指针

 int i;

 L[MAXSIZE-1].cur=0;

 for (i=0;iMAXSIZE-2;i++)

  L[i].cur=i+1;

 L[MAXSIZE-2].cur=0;

 return OK;

}

Status ClearList(SLinkList L)

{ 

 //初始条件：线性表L已存在。操作结果：将L重置为空表

 int i,j,k;

 i=L[MAXSIZE-1].cur;

 L[MAXSIZE-1].cur=0;

 k=L[0].cur;

 L[0].cur=i;

 while (i)

 {

  j=i;

  i=L[i].cur;

 }

 L[j].cur=k;

 return OK;

}

BOOL ListEmpty(SLinkList L)

{ 

 //若L是空表，返回TRUE；否则返回FALSE

 if (!L[MAXSIZE-1].cur)

  return TRUE;

 else

  return FALSE;

}

int ListLength(SLinkList L)

{ 

 //返回L中数据元素个数

 int i,len;

 i=L[MAXSIZE-1].cur;

 len=0;

 while (i)

 {

  i=L[i].cur;

  len++;

 }

 return len;

}

Status GetElem(SLinkList L,int i,LElemType *e)

{ 

 //用e返回L中第i个元素的值

 int j,k=MAXSIZE-1;

 if (i1||iListLength(L))

  return ERROR;

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

  k=L[k].cur;

 *e=L[k].data;

 return OK;

}

int LocateElem(SLinkList L,LElemType e) 

{ 

 //在静态单链线性表L中查找第1个值为e的元素。若找到，则返回它在L中的

 //位序，否则返回0。(与其它LocateElem()的定义不同)

 int i=L[MAXSIZE-1].cur;

 while (iL[i].data!=e)

  i=L[i].cur;

 return i;

}

Status PriorElem(SLinkList L,LElemType cur_e,LElemType *pre_e)

{ 

 //初始条件：线性表L已存在

 //操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，

 //          否则操作失败，pre_e无定义

 int i,j;

 i=L[MAXSIZE-1].cur; 

 do{

  j=i;

  i=L[i].cur;

 }while (iL[i].data!=cur_e);

 if (i)

 {

  *pre_e=L[j].data;

  return OK;

 }

 return ERROR;

}

Status NextElem(SLinkList L,LElemType cur_e,LElemType *next_e)

{ 

 //初始条件：线性表L已存在

 //操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，

 //          否则操作失败，next_e无定义

 int i,j;

 i=LocateElem(L,cur_e);

 if (i)

 {

  j=L[i].cur;

  if (j)

  {

   *next_e=L[j].data;

   return OK;

  }

 }

 return ERROR;

}

Status ListInsert(SLinkList L,int i,LElemType e)

{ 

 //在L中第i个元素之前插入新的数据元素e

 int j,k,l;

 k=MAXSIZE-1;

 if (i1||iListLength(L)+1)

  return ERROR;

 j=Malloc(L);

 if (j)

 {

  L[j].data=e;

  for(l=1;l=i-1;l++)

   k=L[k].cur;

  L[j].cur=L[k].cur;

  L[k].cur=j;

  return OK;

 }

 return ERROR;

}

Status ListDelete(SLinkList L,int i,LElemType *e)

{

 //删除在L中第i个数据元素e，并返回其值

 int j,k;

 if (i1||iListLength(L))

  return ERROR;

 k=MAXSIZE-1;

 for (j=1;j=i-1;j++)

  k=L[k].cur;

 j=L[k].cur;

 L[k].cur=L[j].cur;

 *e=L[j].data;

 Free(L,j);

 return OK;

}

Status ListTraverse(SLinkList L,void (* visit)(LElemType e))

{ 

 int i=L[MAXSIZE-1].cur;

 while (i)

 {

  visit(L[i].data);

  i=L[i].cur;

 }

 return OK;

}

void Visit(LElemType e)

{

 printf(“%d\n”,e);

}

int main()

{

 int i,j,k;

 LElemType e,e0;

 SLinkList L;

 InitList(L);

 for(j=1;j=5;j++)

  i=ListInsert(L,1,j);

 ListTraverse(L,Visit);

 //判断链表是否为空

 i=ListEmpty(L);

 printf(“%d\n”,i);

 //打印链表长度

 printf(“%d\n”,ListLength(L));

 //清空静态链表

 ClearList(L);

 ListTraverse(L,Visit);

 for(j=1;j=10;j++)

  ListInsert(L,j,j);

 //插入新节点后

 ListTraverse(L,Visit);

 //获取链表中的第5个元素

 GetElem(L,5,e);

 printf(“%d\n”,e);

 for(j=0;j=1;j++)

 {

  k=LocateElem(L,j);

  if(k)

   printf(“%d %d\n”,j,k);//j在链表中的序号k

  else

   printf(“Can’t find %d\n”,j);//链表中不存在j

 }

 for(j=1;j=2;j++) //测试头两个数据

 {

  GetElem(L,j,e0); //把第j个数据赋给e0

  i=PriorElem(L,e0,e); //求e0的前驱

  if(!i)

   printf(“No elem before %d\n”,e0);

  else

   printf(“Elem before %d is %d\n”,e0,e);//数据e0的前驱

 }

 for(j=ListLength(L)-1;j=ListLength(L);j++) //最后两个数据

 {

  GetElem(L,j,e0); //把第j个数据赋给e0

  i=NextElem(L,e0,e); //求e0的后继

  if(!i)

   printf(“No elem after %d\n”,e0);

  else

   printf(“The elem after % is %d\n”,e0,e);//数据e0的后继

 }

 k=ListLength(L); //k为表长

 for(j=k+1;j=k;j–)

 {

  i=ListDelete(L,j,e); //删除第j个数据

  if(i)

   printf(“Delete Succussfully\n”);

  else

   printf(“Can’t find the elem\n”,j);

 }

 ListTraverse(L,Visit);

 return 0;

}

给你找了个静态链表的代码，能编译运行