C语言代码大全

法口诀表
#include
#include
void main(void)
{
int ijxy
clrscr()
printf(\n\n * * * 法口诀表 * * * \n\n)
x9
y5
for(i1i<9i++)
{
gotoxy(xy)
printf(2d i)
x+3
}
x7
y6
for(i1i<9i++)
{
gotoxy(xy)
printf(2d i)
y++
}
x9
y 6
for(i1i<9i++)
{
for(j1j<9j++)
{
gotoxy(xy)
printf(2d i*j)
y++
}
y9
x+3
}
printf(\n\n)
}

维数组统计学生成绩
#include
void main()
{
char SelectKeyCreditMoneyDebitMoney
while(1)
{
do{
clrscr()
puts()
puts(| Please select key |)
puts(| 1 Quary |)
puts(| 2 Credit |)
puts(| 3 Debit |)
puts(| 4 Return |)
puts()
SelectKey getch()
}while( SelectKey'1' && SelectKey'2' && SelectKey'3' &&
SelectKey'4' )
switch(SelectKey)
{
case '1'
clrscr()
puts()
puts(| Your balance is 1000 |)
puts(| Press any key to return |)
puts()
getch()
break
case '2'
do{
clrscr()
puts()
puts(| Please select Credit money |)
puts(| 1 50 |)
puts(| 2 100 |)
puts(| 3 Return |)
puts()
CreditMoney getch()
}while( CreditMoney'1' && CreditMoney'2' && CreditMoney'3' )
switch(CreditMoney)
{
case '1'
clrscr()
puts()
puts(| Your Credit money is 50Thank you |)
puts(| Press any key to return |)
puts()
getch()
break
case '2'
clrscr()
puts()
puts(| Your Credit money is 100Thank you |)
puts(| Press any key to return |)
puts()
getch()
break
case '3'
break
}
break
case '3'
do{
clrscr()
puts()
puts(| Please select Debit money |)
puts(| 1 50 |)
puts(| 2 100 |)
puts(| 3 500 |)
puts(| 4 1000 |)
puts(| 5 Return |)
puts()
DebitMoney getch()
}while( DebitMoney'1' && DebitMoney'2' && DebitMoney'3' &&DebitMoney'4' && DebitMoney'5' )
switch(DebitMoney)
{
case '1'
clrscr()
puts()
puts(| Your Debit money is 50Thank you |)
puts(| Press any key to return |)
puts()
getch()
break
case '2'
clrscr()
puts()
puts(| Your Debit money is 100Thank you |)
puts(| Press any key to return |)
puts()
getch()
break
case '3'
clrscr()
puts()
puts(| Your Debit money is 500Thank you |)
puts(| Press any key to return |)
puts()
getch()
break
case '4'
clrscr()
puts()
puts(| Your Debit money is 1000Thank you |)
puts(| Press any key to return |)
puts()
getch()
break
case '5'
break
}
break
case '4'
clrscr()
puts()
puts(| Thank you for your using |)
puts(| Good bye |)
puts()
return

}
}

模拟ATM（动柜员机）界面
#include void main()
{
int Password0Number0price58i0
while( Password 1234 )
{
if( i > 3 )
return
i++
puts(Please input Password )
scanf(d&Password)
}
i0
while( Numberprice )
{
do{
puts(Please input a number between 1 and 100 )
scanf(d&Number)
printf(Your input number is d\nNumber)
}while( (Number>1 && Number<100) )
if( Number > 90 )
{
printf(Too Bigger Press any key to try again\n)
}
else if( Number > 70 && Number < 90 )
{
printf(Bigger\n)
}
else if( Number > 1 && Number < 30 )
{
printf(Too Small Press any key to try again\n)
}
else if( Number > 30 && Number < 50 )
{
printf(Small Press any key to try again\n)
}
else
{
if( Number price )
{
printf(OK You are right Bye Bye\n)
}
else if( Number < price )
{
printf(SorryOnly a little smaller Press any key to try again\n)
}
else if( Number > price )
{
printf( Sorry Only a little bigger Press any key to try again\n)
}
getch()
}
}

二维数组实现矩阵转置
* 二维数组实现矩阵转置 *
#include
#define ROW 3
#define COL 4
main()
{
int matrixA[ROW][COL]matrixB[COL][ROW]
int ij clrscr()
printf(Enter elements of the matrixA)
printf(d*d\nROWCOL)
for( i0 i{
for( j0 j{
scanf(d&matrixA[i][j])
}
}
for( i0 i{
for( j0 j{
matrixB[j][i] matrixA[i][j]
}
}
printf(MatrixB)
printf(d*d\nCOLROW)
for( i0 i{
for( j0 j{
printf(8dmatrixB[i][j])
}
printf(\n)
}
printf(\n Press Any Key to Quit \n)
getch()
}

求解二维数组元素
#define MAXN 20
int a[MAXN][MAXN]
main()
{
int min * 存储值 *
max * 存储值 *
int rowcoln
clrscr()
printf(Please input the order of the matrix\n)* 输入方阵阶次 *
scanf(d&n)
printf(Please input the elements of the matrix\n from a[0][0] to a
[d][d]\nn1n1)
for(row0rowfor(col0colscanf(d&a[row][col])
for(mina[0][0]row0row{
* 行选出数 *
for(maxa[row][0]col1colif(maxmaxa[row][col]
if(min>max)* 保存row行数 *
minmax
}
printf(The minimum of maximum number is d\nmin)
for(maxa[0][0]row0row{
* 行选出数 *
for(mina[row][0]col1colif(min>a[row][col])
mina[row][col]
if(maxmaxmin
}
printf(The maximum of minimum numbers is d\nmax)
printf(\nPress any key to quit\n)
getch()
}

利数组求前n质数
#define N 50
main()
{
int primes[N]
int pcmk clrscr()
printf(\n The first d prime numbers are\nN)
primes[0]2*2第质数*
pc 1*已第质数*
m 3*测试数3开始*
while(pc{
*调整m质数*
k0
while(primes[k]*primes[k]if(mprimes[k]0)
{*m合数*
m+2*m取奇数*
k1*必primes[0]2测试mk开始*
}
else
k++*继续质数测试*
primes[pc++]m
m+2*2外余质数均奇数*
}
*输出primes[0]primes[pc1]*
for(k0kprintf(4dprimes[k])
printf(\n\n Press any key to quit\n )
getch()
}

编制万年历
#include stdioh
long int f(int yearint month)
{*f(年月)＝年－1月<3否f(年月)＝年*
if(month<3) return year1
else return year
} long int g(int month)
{*g(月)＝月＋13月<3否g(月)＝月＋1*
if(month<3) return month+13
else return month+1
} long int n(int yearint monthint day)
{
*N1461*f(年月)4+153*g(月)5+日*
return 1461L*f(yearmonth)4+153L*g(month)5+day
} int w(int yearint monthint day)
{
*w(N621049)7(0return(int)((n(yearmonthday)7621049L7+7)7)
} int date[12][6][7]
int day_tbl[ ][12]{{312831303130313130313031}
{312931303130313130313031}}
main()
{int swleapijkwdday
int year*年*
char title[]SUN MON TUE WED THU FRI SAT
clrscr()
printf(Please input the year whose calendar you want to know )*输
入年*
scanf(d*c&year)*输入年份值掠值回车*
sww(year11)
leapyear40&&year100||year4000*判闰年*
for(i0i<12i++)
for(j0j<6j++)
for(k0k<7k++)
date[i][j][k]0*日期表置0*
for(i0i<12i++)*年十二月*
for(wd0day1day{*第i＋1月日期填入日期表*
date[i][wd][sw]day
sw++sw7*星期七天06计数*
if(sw0) wd++*日期表七天行星期天开始新行*
} printf(\n|The Calendar of Year d
|\n|year)
for(i0i<6i++)
{*先测算第i+1月第i+7月星期数*
for(wd0k0k<7k++)*日期表第六行日期wd0*
wd+date[i][5][k]+date[i+6][5][k]
wdwd65
printf(2d s 2d s |\n|i+1titlei+7title)
for(j0j{
printf( )*输出四空白符*
*左栏第i+1月右栏第i+7月*
for(k0k<7k++)
if(date[i][j][k])
printf(4ddate[i][j][k])
else printf( )
printf( )*输出十空白符*
for(k0k<7k++)
if(date[i+6][j][k])
printf(4ddate[i+6][j][k])
else printf( )
printf( |\n|)
}
*scanf(*c)*键入回车输出月日历*

}
puts
(|)

puts(\n Press any key to quit)
getch()
}

数组元素排序
rest(int a[] int n)
{
int ilowhight for(i0low0highn1i{
if(a[i]>0)
{
*a[i]a[high]交换high减1*
ta[i]
a[i]a[high]
a[high]t
high
}
else if(a[i]0)
i++ * 掠该元素 *
else
{
*a[i]a[low]交换low增1 i增1*
ta[i]
a[i]a[low]
a[low]t
low++
i++
}
}
}
int s[]{8401605}
main()
{
int i
clrscr()
printf(\n The arry before rest is\n)
for(i0iprintf(4ds[i])
rest(ssizeof(s)sizeof(s[0]))
printf(\n The arry after rest is\n)
for(i0iprintf(4ds[i])
printf(\n Press any key to quit\n)
getch()
}

意进制数转换
* 函数trans符号整数n翻译成d（2<＝d<＝16）进制表示字符串s *
#define M sizeof(unsigned int)*8
int trans(unsigned n int d char s[])
{
static char digits[] 0123456789ABCDEF * 十六进制数字字符 *
char buf[M+1]
int j i M
if(d<2||d>16)
{
s[0]'\0' * 合理进制置s空字符串 *
return 0 * 合理进制函数返回0 *
}
buf[i]'\0'
do
{
buf[i]digits[nd] *译出低位应字符存入应工作数组中*
nd
}while(n)
* 译出工作数组中字符串复制s *
for(j0(s[j]buf[i])'\0'j++i++)
* 中控制条件简写成s[j]buf[i] *
return j
}
* 函数测试函数 trans() *
main()
{
unsigned int num 253
int scale[]{2310161}
char str[33]
int i
clrscr()
for(i0i{
if(trans(numscale[i]str))
printf(5d s(d)\nnumstrscale[i])
else
printf(5d > (d) Error \nnumscale[i])
}
printf(\n Press any key to quit\n)
getch()
}

判断回文数
* 函数circle判断正整数nd进制数表示形式否回文数 *
int circle(int n int d)
{
int s0mn
while(m)
{
ss*d+md
md
}
return sn
}
* main函数测试circle函数 *
int num[]{23227851}
int scale[]{21016}
main()
{
int ij
clrscr()
for(i0ifor(j0jif(circle(num[i]scale[j]))
printf(d > (d) is a Circle Number\nnum[i]scale[j])
else
printf(d > (d) is not a Circle Number\nnum[i]scale[j])
printf(\n Press any key to quit\n)
getch()
}

求解钢材切割佳订单
#include
#define N 20
#define DELTA 2
int bestlen
int bestsele[N]
int sele[N]
int n
int orderlen[N]
int total
main()
{
int i
clrscr()
printf(\n Please enter total length of the steel\n)* 输入钢材总长
*
scanf(d&total)
printf(\n Please enter number of order\n) * 输入定单数 *
scanf(d&n)
printf(\n Please enter the orders\n) * 输入定单 *
for(i0iscanf(d&orderlen[i])
bestlen0 *佳解料初值 *
for(i0isele[i]bestsele[i]0 *置前选择佳选择初值 *
try() * 调函数求解 *
for(i0iif(bestsele[i])
printf(order d length d\ni+1orderlen[i])
printf(\n Press any key to quit)
getch()
}
try()
{
int ilen
for(leni0iif(sele[i])
len+orderlen[i]+DELTA
if(lenDELTA{
if(bestlen < len)
{
* 找更解 *
bestlen len
for(i0ibestsele[i]sele[i]
}
for(i0iif(sele[i])
{
sele[i]1 * 做选中尝试*
try()
sele[i]0
}
}
}

指数组指针
main()
{
int xyz * 定义三int型变量 *
int *xp &x * 定义指针变量xp赋值x址xp指x *
*yp &y * 定义指针变量yp赋值y址yp指y *
*zp &z * 定义指针变量zp赋值z址zp指z *
int t
clrscr()
printf(\nPlease input xyz\n)
scanf(dddxpypzp) * 通变量指针变量输入值 *
if(*xp>*yp) * 通指变量指针引变量值 *
{
t*xp * 通指变量指针引变量值 *
*xp*yp* 通指变量x指针xp引变量x值 *
*ypt * 通指变量y指针yp引变量y值 *
}
if(*xp>*zp) * 通指变量指针引变量值 *
{
t*xp * 通指变量x指针xp引变量x值 *
*xp*zp* 通指变量x指针xp引变量x值 *
*zpt * 通指变量z指针zp引变量z值 *
}
if(*yp>*zp) * 通指变量指针引变量值 *
{
t*yp * 通指变量指针引变量值 *
*yp*zp* 通指变量y指针yp引变量y值 *
*zpt* 通指变量z指针zp引变量z值 *
}
printf(x d\ty d\tz d\nxyz)
printf(\nPress any key to quit\n)
getch()
}

阿拉伯数字转换罗马数字
#include
#define ROWS 4
#define COLS 4
int nums[ROWS][COLS]{{1000100010001000}
{900500400100}
{90504010}
{9541}}
char *roms[ROWS][COLS]{{mmmm}
{cmdcdc}
{xclxlx}
{ixvivi}} main(int argcchar *argv[ ])
{
int lowhigh
char roman[25] if(argc<2)
{ printf(Usageroman decimal_number\n)*运行程序需带整数参数*
exit(0)
}
highlowatoi(argv[1])*第参数转换成整数*
checknum(low)
if(argc>2)
{*带两参数*
highatoi(argv[2])
checknum(high)
if(low>high)
{
lowhigh
highatoi(argv[1])
}
}
else
low1
for(low{
to_roman(lowroman)
printf(d\ts\nlowroman)
}
} checknum(int val)*检查参数合理性*
{
if(val<1||val>9999)
{
printf(The number must be in range 19999\n)
exit(0)
}
}
to_roman(int decimalchar roman[ ])*整数转换成罗马数字表示*
{
int powerindex
roman[0]'\0'
for(power0powerfor(index0indexwhile(decimal>nums[power][index])
{
strcat(romanroms[power][index])
decimalnums[power][index]
}
}

通讯录输入输出
#include
#define ZIPLEN 10
#define PHONLEN 15
*struct addr类型定义* struct addr
{
char *name*姓名*
char *address*址*
char zip[ZIPLEN]*邮政编码*
char phone[PHONLEN]*电话号码*
} main()*函数示意述输入输出函数法*
{
struct addr p[100]
int ij
clrscr()
for(i0readaddr(p+i)i++)
for(j0jputs(\n Press any key to quit)
getch()
} * 函数readaddr输入通信录函数 *
int readaddr(struct addr *dpt)
{
int len
char buf[120]*输入字符串缓区* printf(\nPlease input the
Name\n)*输入姓名*
if(scanf(sbuf)1)
{
lenstrlen(buf)
dpt>name(char *)malloc(len+1)*申请存贮姓名空间*
strcpy(dpt>namebuf)
}
else return 0*Ctrl+Z结束输入*
printf(Please input the Address\n)*输入址*
if(scanf(sbuf)1)
{
lenstrlen(buf)
dpt>address(char *)malloc(len+1)*申请存贮址空间*
strcpy(dpt>addressbuf)
}
else
{*Ctrl+Z结束输入*
free(dpt>name)*释放存贮姓名空间*
return 0
}
printf(Please input the Zip code\n)*输入邮编*
if(scanf(sbuf)1)
strncpy(dpt>zipbufZIPLEN1)
else
{
free(dpt>name)*释放存贮姓名空间*
free(dpt>address)*释放存贮址空间*
return 0*Ctrl+Z结束输入*
}
printf(Please input the Phone number\n)*输入电话号码*
if(scanf(sbuf)1)
strncpy(dpt>phonebufPHONLEN1)
else
{
free(dpt>name)
free(dpt>address)
return 0*Ctrl+Z结束输入*
}
return 1
} * 函数writeaddr输出通讯录 *
int writeaddr(struct addr*dpt)
{
printf(Name s\n dpt>name)*输出姓名*
printf(Address s\n dpt>address)*输出址*
printf(Zip s\n dpt>zip)*输出邮编*
printf(Phone s\n\n dpt>phone)*输出电话号码*
}

扑克牌结构表示
enum suits{CLUBSDIAMONDSHEARTSSPADES}
struct card
{
enum suits suit
char value[3]
}
struct card deck[52]
char cardval[][3]
{A2345678910JQK}
char suitsname[][9]{CLUBSDIAMONDSHEARTSSPADES} main()
{
int ij
enum suits s
clrscr()
for(i0i<12i++)
for(sCLUBSs{
ji*4+s
deck[j]suits
strcpy(deck[j]valuecardval[i])
}
for(j0j<52j++)
printf((s3s)csuitsname[deck[j]suit]deck[j]valuej
43'\n''\t')
puts(\nPress any key to quit)
getch()
}

结构统计学生成绩
#include
#define N 200
#define SCORES 5
#define NUMLEN 10
struct std_type{
char no[NUMLEN]*学号*
char *name*名字符串指针*
int scores[SCORES]*五门功课成绩*
}
struct std_type students[N]
int order[N]
int total[N] *[函数]输入学生信息函数*
int readastu(struct std_type *spt)
{
int lenj
char buf[120]*输入字符串缓区* printf(\nNumber )*输入学号
*
if(scanf(sbuf)1)
strncpy(spt>nobufNUMLEN1)
else
return 0*Ctrl+Z结束输入*
printf(Name )*输入姓名*
if(scanf(sbuf)1)
{
lenstrlen(buf)
spt>name(char *)malloc(len+1)*申请存贮姓名空间*
strcpy(spt>namebuf)
}
else return 0*Ctrl+Z结束输入*
printf(Scores )*输入成绩*
for(j0jif(scanf(dspt>scores+j)1)
break
if(j0)*成绩未输入*
{
free(spt>name)*释放存贮姓名空间*
return 0
}
for(jspt>scores[j]0
return 1
} *[函数]输出学生信息函数*
int writeastu(struct std_type *spt)
{
int i printf(Number s\nspt>no)*输出学号*
printf(Name s\nspt>name)*输出姓名*
printf(Scores )*输出成绩*
for(i0iprintf(4dspt>scores[i])
printf(\n\n)
} main()
{
int nijt clrscr()
for(n0readastu(students+n)n++)
*采泡法学生信息数组排序*
for(i0i{
order[i]i*预置第i输入学生*
for(t0j0jt+students[i]scores[j]
total[i]t
}
*泡排序*
for(i0ifor(j0jif(total[order[j]]{*交换名次*
torder[j]
order[j]order[j+1]
order[j+1]t
}
for(j0jwriteastu(students+order[j])
printf(\n Press any key to quit\n)
getch()
}

报数游戏
#include
struct ele{
int no
struct ele *link
}
main()
{
int nmi
struct ele *h*u*p
clrscr()
printf(Please input n&m\n)
scanf(dd&n&m)*输入nm*
hu(struct ele *)malloc(sizeof(struct ele))*形成首表元*
h>no1
for(i2i{
u>link(struct ele *)malloc(sizeof(struct ele))
uu>link
u>noi*第i表元置编号i*
}
u>linkh*末表元继首表元形成环*
puts(\nThe numbers of who will quit the cycle in turn are)
while(n)
{
for(i1iuu>link
pu>link*p指第m表元*
u>linkp>link*第m表元环中脱钩*
printf(4dp>no)
free(p)*释放第m表元占空间*
n
}
printf(\n\n Press any key to quit\n)
getch()
}

学生成绩理程序
*
学生成绩理程序
编制统计学生考试分数理程序
设学生成绩已学生记录形式存储文件中
位学生记录包含信息：姓名学号门功课成绩
程序具项功：求出门课程总分均分姓名
学号寻找记录显示浏览全部学生成绩总分高低显示学生信息等

* #include
#define SWN 3 * 课程数 *
#define NAMELEN 20 * 姓名字符数 *
#define CODELEN 10 * 学号字符数 *
#define FNAMELEN 80 * 文件名字符数 *
#define BUFLEN 80 * 缓区字符数 *
* 课程名称表 *
char schoolwork[SWN][NAMELEN+1] {ChineseMathematicEnglish}
struct record
{
char name[NAMELEN+1] * 姓名 *
char code[CODELEN+1] * 学号 *
int marks[SWN] * 课程成绩 *
int total * 总分 *
}stu struct node
{
char name[NAMELEN+1] * 姓名 *
char code[CODELEN+1] * 学号 *
int marks[SWN] * 课程成绩 *
int total * 总分 *
struct node *next * 续表元指针 *
}*head * 链表首指针 * int total[SWN] * 课程总分 *
FILE *stfpt * 文件指针 *
char stuf[FNAMELEN] * 文件名 * * 指定文件读入记录 *
int readrecord(FILE *fptstruct record *rpt)
{
char buf
int i
if(fscanf(fptsbuf)1)
return 0 * 文件结束 *
strncpy(rpt>namebufNAMELEN)
fscanf(fptsbuf)
strncpy(rpt>codebufCODELEN)
for(i0ifscanf(fptd&rpt>marks[i])
for(rpt>total0i0irpt>total+rpt>marks[i]
return 1
}
* 指定文件写入记录 *
writerecord(FILE *fptstruct record *rpt)
{
int i
fprintf(fpts\nrpt>name)
fprintf(fpts\nrpt>code)
for(i0ifprintf(fptd\nrpt>marks[i])
return
} * 显示学生记录 *
displaystu(struct record *rpt)
{
int i
printf(\nName s\nrpt>name)
printf(Code s\nrpt>code)
printf(Marks \n)
for(i0iprintf( 15s 4d\nschoolwork[i]rpt>marks[i])
printf(Total 4d\nrpt>total)
} * 计算单科总分 *
int totalmark(char *fname)
{
FILE *fp
struct record s
int counti
if((fpfopen(fnamer))NULL)
{
printf(Can't open file s\nfname)
return 0
}
for(i0itotal[i]0
count0
while(readrecord(fp&s)0)
{
for(i0itotal[i]+smarks[i]
count++
}
fclose(fp)
return count * 返回记录数 *
} * 列表显示学生信息 *
void liststu(char *fname)
{
FILE *fp
struct record s
if((fpfopen(fnamer))NULL)
{
printf(Can't open file s\nfname)
return
}
while(readrecord(fp&s)0)
{
displaystu(&s)
printf(\n Press ENTER to continue\n)
while(getchar()'\n')
}
fclose(fp)
return
} * 构造链表 *

struct node *makelist(char *fname)
{
FILE *fp
struct record s
struct node *p*u*v*h
int i
if((fpfopen(fnamer))NULL)
{
printf(Can't open file s\nfname)
return NULL
}
hNULL
p(struct node *)malloc(sizeof(struct node))
while(readrecord(fp(struct record *)p)0)
{
vh
while(v&&p>totaltotal)
{
uv
vv>next
}
if(vh)
hp
else
u>nextp
p>nextv
p(struct node *)malloc(sizeof(struct node))
}
free(p)
fclose(fp)
return h
} * 序显示链表表元 *
void displaylist(struct node *h)
{
while(hNULL)
{
displaystu((struct record *)h)
printf(\n Press ENTER to continue\n)
while(getchar()'\n')
hh>next
}
return
}
* 学生姓名查找学生记录 *
int retrievebyn(char *fname char *key)
{
FILE *fp
int c
struct record s
if((fpfopen(fnamer))NULL)
{
printf(Can't open file s\nfname)
return 0
}
c0
while(readrecord(fp&s)0)
{
if(strcmp(snamekey)0)
{
displaystu(&s)
c++
}
}
fclose(fp)
if(c0)
printf(The student s is not in the file s\nkeyfname)
return 1
} * 学生学号查找学生记录 *
int retrievebyc(char *fname char *key)
{
FILE *fp
int c
struct record s
if((fpfopen(fnamer))NULL)
{
printf(Can't open file s\nfname)
return 0
}
c0
while(readrecord(fp&s)0)
{
if(strcmp(scodekey)0)
{
displaystu(&s)
c++
break
}
}
fclose(fp)
if(c0)
printf(The student s is not in the file s\nkeyfname)
return 1
} main()
{
int ijn
char c
char buf
FILE *fp
struct record s
clrscr()
printf(Please input the students marks record file's name )
scanf(sstuf)
if((fpfopen(stufr))NULL)
{
printf(The file s doesn't exit do you want to creat it (YN)
stuf)
getchar()
cgetchar()
if(c'Y'||c'y')
{
fpfopen(stufw)
printf(Please input the record number you want to write to the file
)
scanf(d&n)
for(i0i{
printf(Input the student's name )
scanf(s&sname)
printf(Input the student's code )
scanf(s&scode)
for(j0j{
printf(Input the s mark schoolwork[j])
scanf(d&smarks[j])
}
writerecord(fp&s)
}
fclose(fp)
}
}
fclose(fp)
getchar()
*clrscr()*
puts(Now you can input a command to manage the records)
puts(m mean of the marks)
puts(t total of the marks)
puts(n search record by student's name)
puts(c search record by student's code)
puts(l list all the records)
puts(s sort and list the records by the total)
puts(q quit)
while(1)
{
puts(Please input command)
scanf( c&c) * 输入选择命令 *
if(c'q'||c'Q')
{
puts(\n Thank you for your using)
break * q结束程序运行 *
}
switch(c)
{
case 'm' * 计算均分 *
case 'M'
if((ntotalmark(stuf))0)
{
puts(Error)
break
}
printf(\n)
for(i0iprintf(15s's average is 2f\nschoolwork[i](float)total[i]n)
break
case 't' * 计算总分 *
case 'T'
if((ntotalmark(stuf))0)
{
puts(Error)
break
}
printf(\n)
for(i0iprintf(15s's total mark is d\nschoolwork[i]total[i])
break
case 'n' * 学生姓名寻找记录 *
case 'N'
printf(Please input the student's name you want to search )
scanf(sbuf)
retrievebyn(stufbuf)
break
case 'c' * 学生学号寻找记录 *
case 'C'
printf(Please input the student's code you want to search )
scanf(sbuf)
retrievebyc(stufbuf)
break
case 'l' * 列出学生记录 *
case 'L'
liststu(stuf)
break
case 's' * 总分高低排列显示 *
case 'S'
if((headmakelist(stuf))NULL)
displaylist(head)
break
default break
}
}
}

插入排序
#include
#define MAX 255
int R[MAX]
void Insert_Sort(int n)
{ * 数组R中记录R[1n]递增序进行插入排序 *
int ij
for(i2iif(R[i]{* R[i]等序区中RR[i] *
* 应原位置 *
R[0]R[i]ji1 * R[0]哨兵R[i]副 *
do{ * 右左序区R[1．．i1]中查找R[i]插入位置 *
R[j+1]R[j] * 关键字R[i]记录移 *
j
}while(R[0]R[j+1]R[0] * R[i]插入正确位置 *
}
} main()
{
int in
clrscr()
puts(Please input total element number of the sequence)
scanf(d&n)
if(n<0||n>MAX)
{
printf(n must more than 0 and less than d\nMAX)
exit(0)
}
puts(Please input the elements one by one)
for(i1iscanf(d&R[i])
puts(The sequence you input is)
for(i1iprintf(4dR[i])
Insert_Sort(n)
puts(\nThe sequence after insert_sort is)
for(i1iprintf(4dR[i])
puts(\n Press any key to quit)
getchar()
getchar()
}

希尔排序
#include
#define MAX 255
int R[MAX]
void Bubble_Sort(int n)
{ * R（ln)排序文件采扫描R做泡排序 *
int ij
int exchange * 交换标志 *
for(i1iexchange0 * 趟排序开始前交换标志应假 *
for(jn1j>ij) * 前序区R[in]扫描 *
if(R[j+1]R[0]R[j+1] * R[0]哨兵仅做暂存单元 *
R[j+1]R[j]
R[j]R[0]
exchange1 * 发生交换交换标志置真 *
}
if(exchange) * 趟排序未发生交换提前终止算法 *
return
}
} void main()
{
int in
clrscr()
puts(Please input total element number of the sequence)
scanf(d&n)
if(n<0||n>MAX)
{
printf(n must more than 0 and less than d\nMAX)
exit(0)
}
puts(Please input the elements one by one)
for(i1iscanf(d&R[i])
puts(The sequence you input is)
for(i1iprintf(4dR[i])
Bubble_Sort(n)
puts(\nThe sequence after bubble_sort is)
for(i1iprintf(4dR[i])
puts(\n Press any key to quit)
getchar()
getchar()
}

泡排序
#include
#define MAX 255
int R[MAX]
int Partition(int iint j)
{* 调Partition(Rlowhigh)时R[lowhigh]做划分*
* 返回基准记录位置 *
int pivotR[i] * 区间第1记录作基准 *
while(iwhile(ipivot) * pivot相位置i *
j * 右左扫描查找第1关键字pivotkey记录R[j] *
if(iR[i++]R[j] * 相交换R[i]R[j]交换i指针加1 *
while(ii++ * 左右扫描查找第1关键字pivotkey记录R[i] *
if(ipivotkey *
R[j]R[i] * 相交换R[i]R[j]交换j指针减1 *
} * endwhile *
R[i]pivot * 基准记录已定位*
return i
} * end of partition * void Quick_Sort(int lowint high)
{ * R[lowhigh]快速排序 *
int pivotpos * 划分基准记录位置 *
if(lowpivotposPartition(lowhigh) * R[lowhigh]做划分 *
Quick_Sort(lowpivotpos1) * 左区间递排序 *
Quick_Sort(pivotpos+1high) * 右区间递排序 *
}
} * end of Quick_Sort *
void main()
{
int in
clrscr()
puts(Please input total element number of the sequence)
scanf(d&n)
if(n<0||n>MAX)
{
printf(n must more than 0 and less than d\nMAX)
exit(0)
}
puts(Please input the elements one by one)
for(i1iscanf(d&R[i])
puts(The sequence you input is)
for(i1iprintf(4dR[i])
Quick_Sort(1n)
puts(\nThe sequence after quick_sort is)
for(i1iprintf(4dR[i])
puts(\n Press any key to quit)
getch()

}

快速排序
#include
#define MAX 255
int R[MAX]
void ShellPass(int d int n)
{* 希尔排序中趟排序d前增量 *
int ij
for(id+1iif(R[i]{
R[0]R[i]jid * R[0]暂存单元哨兵 *
do {* 查找R[i]插入位置 *
R[j+d]R[j]* 移记录 *
jjd * 查找前记录 *
}while(j>0&&R[0]R[j+d]R[0] * 插入R[i]正确位置 *
} * endif *
} * end of ShellPass * void Shell_Sort(int n)
{
int incrementn * 增量初值妨设n>0 *
do {
incrementincrement3+1 * 求增量 *
ShellPass(incrementn) * 趟增量incrementShell插入排序 *
}while(increment>1)
} * ShellSort *
void main()
{
int in
clrscr()
puts(Please input total element number of the sequence)
scanf(d&n)
if(n<0||n>MAX)
{
printf(n must more than 0 and less than d\nMAX)
exit(0)
}
puts(Please input the elements one by one)
for(i1iscanf(d&R[i])
puts(The sequence you input is)
for(i1iprintf(4dR[i])
Shell_Sort(n)
puts(\nThe sequence after shell_sort is)
for(i1iprintf(4dR[i])
puts(\n Press any key to quit)
getch()

}

选择排序
#include
#define MAX 255
int R[MAX]
void Select_Sort(int n)
{
int ijk
for(i1i{* 做第i趟排序(1≤i≤n1) *
ki
for(ji+1jif(R[j]kj * k记目前找关键字位置 *
if(ki)
{ * 交换R[i]R[k] *
R[0]R[i] R[i]R[k] R[k]R[0] * R[0]作暂存单元 *
} * endif *
} * endfor *
} * end of Select_Sort * void main()
{
int in
clrscr()
puts(Please input total element number of the sequence)
scanf(d&n)
if(n<0||n>MAX)
{
printf(n must more than 0 and less than d\nMAX)
exit(0)
}
puts(Please input the elements one by one)
for(i1iscanf(d&R[i])
puts(The sequence you input is)
for(i1iprintf(4dR[i])
Select_Sort(n)
puts(\nThe sequence after select_sort is)
for(i1iprintf(4dR[i])
puts(\n Press any key to quit)
getch()

}

堆排序
#include
#define MAX 255
int R[MAX] void Heapify(int sint m)
{ *R[1n]进行堆调整temp做暂存单元 *
int jtemp
tempR[s]
j2*s
while (j{
if (R[j]>R[j+1]&&jif (tempR[s]R[j]
sj
jj*2
}* end of while *
R[s]temp
} * end of Heapify * void BuildHeap(int n)
{ * 序序列建成堆 *
int i
for(in2i>0i)
Heapify(in)
}
void Heap_Sort(int n)
{ * R[1n]进行堆排序妨R[0]做暂存单元 *
int i
BuildHeap(n) * R[1n]建成初始堆 *
for(ini>1i)
{ * 前序区R[1i]进行堆排序做n1趟 *
R[0]R[1] R[1]R[i]R[i]R[0] * 堆顶堆中记录交换 *
Heapify(1i1) * R[1i1]重新调整堆仅R[1]违反堆性质 *
} * end of for *
} * end of Heap_Sort *
void main()
{
int in
clrscr()
puts(Please input total element number of the sequence)
scanf(d&n)
if(n<0||n>MAX)
{
printf(n must more than 0 and less than d\nMAX)
exit(0)
}
puts(Please input the elements one by one)
for(i1iscanf(d&R[i])
puts(The sequence you input is)
for(i1iprintf(4dR[i])
Heap_Sort(n)
puts(\nThe sequence after Big heap_sort is)
for(i1iprintf(4dR[i])
puts(\n Press any key to quit)
getch()

}

排序
#include
#define MAX 255
int R[MAX] void Merge(int lowint mint high)
{* 两序子文件R[lowm)R[m+1high]成序 *
* 子文件R[lowhigh] *
int ilowjm+1p0 * 置初始值 *
int *R1 * R1局部量p定义类型指针速度更快 *
R1(int *)malloc((highlow+1)*sizeof(int))
if(R1) * 申请空间失败 *
{
puts(Insufficient memory available)
return
}
while(iR1[p++](R[i]while(iR1[p++]R[i++]
while(jR1[p++]R[j++]
for(p0ilowiR[i]R1[p]* 完成结果复制回R[lowhigh] *
} * end of Merge *
void Merge_SortDC(int lowint high)
{* 分治法R[lowhigh]进行二路排序 *
int mid
if(low{* 区间长度1 *
mid(low+high)2 * 分解 *
Merge_SortDC(lowmid) * 递R[lowmid]排序 *
Merge_SortDC(mid+1high) * 递R[mid+1high]排序 *
Merge(lowmidhigh) * 组合两序区序区 *
}
}* end of Merge_SortDC *
void main()
{
int in
clrscr()
puts(Please input total element number of the sequence)
scanf(d&n)
if(n<0||n>MAX)
{
printf(n must more than 0 and less than d\nMAX)
exit(0)
}
puts(Please input the elements one by one)
for(i1iscanf(d&R[i])
puts(The sequence you input is)
for(i1iprintf(4dR[i])
Merge_SortDC(1n)
puts(\nThe sequence after merge_sortDC is)
for(i1iprintf(4dR[i])
puts(\n Press any key to quit)
getch()

}

基数排序
#include stdioh
#include conioh
#include stdlibh
#define MAX 5
typedef struct node
{ int k
struct node *next
} *lnode
lnode my_input(int *d)
{ lnode headtempterminal
char s[MAX+1]
printf(Input the records ('0' to end input)\n)
scanf(ss)
headNULL
*d0
terminalNULL
while(s[0]'0')
{
temp(lnode)malloc(sizeof(struct node))
if (strlen(s)>*d)
*dstrlen(s)
temp>katoi(s)
if (headNULL)
{ headtemp
terminaltemp
}
else
{
terminal>nexttemp
terminaltemp
}
scanf(ss)
}
terminal>nextNULL return head
}
void my_output(lnode h)
{
lnode th
printf(\n)
while (hNULL)
{
printf(d h>k)
hh>next
}
ht
* getch() *
}
lnode Radix_Sort(lnode headint d)
{
lnode pqht
int ijxradix1
h(lnode)malloc(10*sizeof(struct node))
t(lnode)malloc(10*sizeof(struct node))
for (idi>1i)
{
for (j0j<9j++)
{ h[j]nextNULL
t[j]nextNULL
}
phead
while (pNULL)
{
x((p>k)radix)10
if (h[x]nextNULL)
{
h[x]nextp
t[x]nextp
}
else
{
qt[x]next
q>nextp
t[x]nextp
}
pp>next
} j0
while (h[j]nextNULL)
j++
headh[j]next
qt[j]next
for (xj+1x<9x++)
if (h[x]nextNULL)
{
q>nexth[x]next
qt[x]next
}
q>nextNULL
radix*10
printf(\n\n)
}
return head
}
void my_free(lnode h)
{
lnode temph
while (temp)
{
htemp>next
free(temp)
temph
}
}
void main()
{
lnode h
int d
clrscr()
hmy_input(&d)
puts(The sequence you input is)
my_output(h)
hRadix_Sort(hd)
puts(\nThe sequence after radix_sort is)
my_output(h)
my_free(h)
puts(\n Press any key to quit)
getch()
}

二叉搜索树操作
#include
#include
struct node {
int value
struct node* left
struct node* right
}
typedef struct node NODE
typedef struct node* PNODE
void new_node (PNODE* n int value) { *n (PNODE)malloc (sizeof
(NODE))
if (*n NULL) {
(*n)>value value
(*n)>left NULL
(*n)>right NULL
}
}
void free_node (PNODE* n) {
if ((*n) NULL) {
free (*n)
*n NULL
}
}
void free_tree (PNODE* n) {
if (*n NULL) return
if ((*n)>left NULL) {
free_tree (&((*n)>left))
}
if ((*n)>right NULL) {
free_tree (&((*n)>right))
}
free_node (n)
}
查找结点
PNODE find_node (PNODE n int value) {
if (n NULL) {
return NULL
} else if (n>value value) {
return n
} else if (value < n>value) {
return find_node (n>left value)
} else {
return find_node (n>right value)
}
}
插入结点
void insert_node (PNODE* n int value) {
if (*n NULL) {
new_node (n value)
} else if (value (*n)>value) {
return
} else if (value < (*n)>value) {
insert_node (&((*n)>left) value)
} else {
insert_node (&((*n)>right) value)
}
}
长路径
int get_max_depth (PNODE n) {
int left 0
int right 0
if (n NULL) {
return 0
}
if (n>left NULL) {
left 1 + get_max_depth (n>left)
}
if (n>right NULL) {
right 1 + get_max_depth (n>right)
}
return (left > right left right )
}
短路径
int get_min_depth (PNODE n) {
int left 0
int right 0
if (n NULL) {
return 0
}
if (n>left NULL) {
left 1 + get_min_depth (n>left)
}
if (n>right NULL) {
right 1 + get_min_depth (n>right)
}
return (left < right left right )
}
int get_num_nodes (PNODE n) {
int left 0
int right 0
if (n NULL) {
return 0
}
if (n>left NULL) {
left get_num_nodes (n>left)
}
if (n>right NULL) {
right get_num_nodes (n>right)
}
return (left + 1 + right)
}
短路径长度
int get_min_value (PNODE n) {
if (n NULL) return 0
if (n>left NULL) {
return n>value
} else {
return get_min_value(n>left)
}
}
长路径长度
int get_max_value (PNODE n) {
if (n NULL) return 0
if (n>right NULL) {
return n>value
} else {
return get_max_value(n>right)
}
}
删结点
void deletenode (PNODE *n) {
PNODE tmp NULL
if (n NULL) return
if ((*n)>right NULL) {
tmp *n
*n (*n)>left

free_node (n)
} else if ((*n)>left NULL) {
tmp *n
*n (*n)>right
free_node (n)
} else {
for (tmp (*n)>right tmp>left NULL tmp tmp>left)
tmp>left (*n)>left
tmp (*n)
*n (*n)>right
free_node (&tmp)
}
}
void delete_node (PNODE *n int value) {
PNODE node
if (n NULL) return
node find_node (*n value)
if ((*n)>value value) {
deletenode (n)
} else if (value < (*n)>value) {
delete_node (&((*n)>left) value)
} else {
delete_node(&((*n)>right) value)
}
}
void pre_order_traversal(PNODE n)
{
if (n NULL) {
printf (i n>value)
pre_order_traversal (n>left)
pre_order_traversal( n>right)
}
}
void in_order_traversal (PNODE n)
{
if (n NULL) {
in_order_traversal (n>left)
printf (i n>value)
in_order_traversal ( n>right)
}
}
void post_order_traversal (PNODE n)
{
if (n NULL) {
post_order_traversal (n>left)
post_order_traversal (n>right)
printf (i n>value)
}
}
int main() {
char buf[50]
int option
PNODE tree NULL
PNODE node NULL
while (1) {
printf (\n)
printf (Options are\n\n)
printf ( 0 Exit\n)
printf ( 1 Insert node\n)
printf ( 2 Delete node\n)
printf ( 3 Find node\n)
printf ( 4 Pre order traversal\n)
printf ( 5 In order traversal\n)
printf ( 6 Post order traversal\n)
printf ( 7 Max depth\n)
printf ( 8 Min depth\n)
printf ( 9 Max value\n)
printf ( 10 Min value\n)
printf ( 11 Node Count\n\n)
printf (\n)
printf (Select an option )
fgets (buf sizeof(buf) stdin)
sscanf (buf i &option)
printf (\n)
if (option < 0 || option > 11) {
fprintf (stderr Invalid option)
continue
}
switch (option) {
case 0
exit (0)
case 1
printf (Enter number to insert )
fgets (buf sizeof(buf) stdin)
sscanf (buf i &option)
printf (\n\n)
insert_node (&tree option)
break
case 2
printf (Enter number to delete )
fgets (buf sizeof(buf) stdin)
sscanf (buf i &option)
printf (\n\n)
delete_node (&tree option)
break
case 3
printf (Enter number to find )
fgets (buf sizeof(buf) stdin)
sscanf (buf i &option)
printf (\n\n)
node find_node (tree option)
if (node NULL) {
printf (Found node\n\n)
} else {
printf (Couldn't find node\n\n)
}
break
case 4
printf (Pre order traversal )
pre_order_traversal (tree)
printf (\n\n)
break
case 5
printf (In order traversal )
in_order_traversal (tree)
printf (\n\n)
break
case 6
printf (Post order traversal )
post_order_traversal (tree)
printf (\n\n)
break
case 7
printf (Max depth is i\n\n get_max_depth (tree))
break
case 8
printf (Min depth is i\n\n get_min_depth (tree))
break
case 9
printf (Max value is i\n\n get_max_value (tree))
break
case 10
printf (Min value is i\n\n get_min_value (tree))
break
case 11
printf (Node Count is i\n\n get_num_nodes (tree))
break
}
}
return 0
}

二项式系数递
#include
#include
#include
int binom (int n int i)
void main (void)
{
int int1
int int2
印两项式
printf (NOTE Entering a figure other than a number will \ncause the
program to crash)
printf (\n)
printf (Formula computation is in B(ni) N 1st integer > 2nd I
Integer\n\n)
printf ( n\n)
printf ( B(ni) \n)
printf (k(ni)\n\n)
printf (Warning Program has no error checking\n\n)
printf (\nEnter an integer )
scanf (d &int1)
printf (\n)
printf (Enter a second integer )
scanf (d &int2)
printf (\n)
printf (Binomial Coefficiant d binom (int1 int2))
getch()
}
算法计算
int binom (int n int i)
{
int n1
int n2
if (( i 0 ) || (n i))
{
return 1
}
else
{
n1 binom ( n 1 i)
n2 binom ( n 1 i 1)
return n1 + n2
}
}

背包问题
#include
#include
#define MAX 100
struct Bag
{ int weight
int value
}Bag[MAX]
int a[MAX]
int Value0
int Weight
int comb(int mint k)
{int ij
int weival
for(imi>ki)
{ a[k]i
if(k>1)
comb(i1k1)
else
{ wei0 * 预值0 *
val0
for(ja[0]j>0j) * 种组合求重量价值 *
{ weiwei+Bag[a[j]]weight
valval+Bag[a[j]]value
}
if(weiValue) * 判断否满足条件进行附值 *
Valueval
}
}
return Value
}
void main()
{ int numsubnum
int l
clrscr()
printf(输入背包总数) * 输入背包总数 *
scanf(d&num)
printf(输入背包重量价值\nnum) * 输入背包重量价值 *
for(l1lscanf(dd&Bag[l]weight&Bag[l]value)
printf(输入满足求背包数\n) * 输入求背包数 *
scanf(d&subnum)
printf(输入满足条件重量\nsubnum) * 输入满足条件重量*
scanf(d&Weight)
a[0]subnum
printf(the max value isdcomb(numsubnum))
getch()
}

序表插入删

#define ListSize 100* 假定表空间100 *
#include
#include
void Error(char * message)
{
printf(错误s\nmessage)
exit(1)
}* 0开始计表空间应101 *
struct Seqlist{
int data[ListSize]* 量data存放表结点 *
int length * 前表长度 *
}
* 定义表结构 * * 两算法 *
void InsertList(struct Seqlist *L int x int i)
{
* 新结点x插入L指序表第i结点ai位置 *
int j
if ( i < 0 || i > L > length )
Error(position error)* 非法位置退出 *
if ( L>length>ListSize )
Error(overflow)
for ( jL>length1 j > i j )
L>data[j+1]L>data [j]
L>data[i]x
L>length++
} void DeleteList ( struct Seqlist *L int i )
{* L指序表中删第i结点ai *
int j
if ( i< 0 || i > L> length1)
Error( position error )
for ( j i+1 j < L> length j++ )
L>data [ j1 ]L>data [ j] * 结点前移 *
L> length * 表长减 *
}
* 验证算法加 *
void Initlist(struct Seqlist *L)
{
L>length0
}
void main()
{
struct Seqlist *SEQA
int i
SEQA (struct Seqlist *)malloc(sizeof(struct Seqlist))
Initlist(SEQA) for (i0i{
InsertList (SEQAii)
printf(d\nSEQA>data[i])
}
DeleteList (SEQA99)
for (i0i{
printf(d\nSEQA>data[i])
}
}

链表操作（1）
#include
#include
#define N 10 typedef struct node
{
char name[20]
struct node *link
}stud stud * creat()
{
stud *p*h*s
int in
puts(\nPlease input the number of linklist)
scanf(d&n)
if((h(stud *)malloc(sizeof(stud)))NULL)
{
printf(cannot find space)
exit(0)
}
h>name[0]'\0'
h>linkNULL
ph
for(i0i{
if((s (stud *) malloc(sizeof(stud)))NULL)
{
printf(cannot find space)
exit(0)
}
p>links
printf(please input d student's name i+1)
scanf(ss>name)
s>linkNULL
ps
} return(h)
} stud * search(stud *hchar *x)
{
stud *p
char *y
ph>link
while(pNULL)
{
yp>name
if(strcmp(yx)0)
return(p)
else pp>link
}
if(pNULL)
printf(data not find)
return 0
} stud * search2(stud *hchar *x)
{
stud *p*s
char *y
ph>link
sh
while(pNULL)
{
yp>name
if(strcmp(yx)0)
return(s)
else
{
pp>link
ss>link
}
}
if(pNULL)
printf(data not find)
return 0
} void insert(stud *p)
{
char stuname[20]
stud *s
if((s (stud *) malloc(sizeof(stud)))NULL)
{
printf(cannot find space)
exit(0)
}
printf(\nplease input the student's name )
scanf(sstuname)
strcpy(s>namestuname)
s>linkp>link
p>links
} void del(stud *xstud *y)
{
stud *s
sy
x>linky>link
free(s)
} void print(stud *h)
{
stud *p
ph>link
printf(Now the link list is\n)
while(pNULL)
{
printf(s &*(p>name))
pp>link
}
printf(\n)
} void quit()
{
clrscr()
puts(\n Thank you for your using\n Press any key to quit)
getch()
exit(0)
} void menu(void)
{
clrscr()
printf( simple linklise realization of c\n)
printf( ||||\n)
printf( || ||\n)
printf( || [1] create linklist ||\n)
printf( || [2] seach ||\n)
printf( || [3] insert ||\n)
printf( || [4] delete ||\n)
printf( || [5] print ||\n)
printf( || [6] exit ||\n)

printf( || ||\n)
printf( || if no list existcreate first ||\n)
printf( || ||\n)
printf( ||||\n)
printf( Please input your choose(16) )
} main()
{
int choose
stud *head*searchpoint*forepoint
char fullname[20]
while(1)
{
menu()
scanf(d&choose)
switch(choose)
{
case 1
clrscr()
headcreat()
puts(Linklist created successfully \nPress any key to return)
getch()
break
case 2
clrscr()
printf(Input the student's name which you want to find\n)
scanf(sfullname)
searchpointsearch(headfullname)
printf(The stud name you want to find iss*&searchpoint>name)
printf(\nPress any key to returen)
getchar()
getchar()
break
case 3
clrscr()
insert(head)
print(head)
printf(\nPress any key to returen)
getchar()getchar()
break
case 4
clrscr()
print(head)
printf(\nInput the student's name which you want to delete\n)
scanf(sfullname)
searchpointsearch(headfullname)
forepointsearch2(headfullname)
del(forepointsearchpoint)
print(head)
puts(\nDelete successfully Press any key to return)
getchar()
getchar()
break
case 5print(head)
printf(\nPress any key to return)
getchar()getchar()
break
case 6quit()
break
default
clrscr()
printf(Illegal letter Press any key to return)
menu()
getchar()
}
}
}

链表操作（2）
#include stdafxh
#include stdioh
#ifndef SQLIST_H
#define SQLIST_H
#include
#define List_INIT_SIZE 100 线性表存储空间初始
#define LIST_INCREMENT 10 分配增量
#define OVERFLOW 2
#define OK 1
#define ERROR 1
#define TRUE 1
#define FALSE 0
typedef int ElemType
typedef struct{
ElemType *elem 存储空间基址
int length 前长度
int size 前存储容量(sizeof(ElemType)单位)
}SqList
int InitList(SqList &L)
{
构建线性表L
Lelem (ElemType*)malloc(List_INIT_SIZE*sizeof(ElemType))
if(Lelem)
{
exit(OVERFLOW)
}
Llength 0
Lsize List_INIT_SIZE
return OK
}InitList void DestoryList(SqList &L)
{
if(Lelem)
{
delete Lelem
Lelem NULL
}
Llength 0
Lsize 0
}DestoryList void ClearList(SqList &L)
{
Lelem NULL
Llength 0
Lsize List_INIT_SIZE
}ClearList int ListEmpty(SqList L)
{
if(Llength > 0)
{
return TRUE
}
else
{
return FALSE
}
}ListEmpty int ListLength(SqList L)
{
return Llength
}ListLength int ListInsert(SqList &L int i ElemType e)
{
if(i<1 || i>ListLength(L)+1) 需满足条件1{
return ERROR
}
ElemType * NewBase 新基址
if(Llength > Lsize) 空间已满
{
NewBase (ElemType*)malloc((Lsize+LIST_INCREMENT)*sizeof(ElemType))
申请新空间
if(NewBase)
{
exit(OVERFLOW)
}
Lelem NewBase
Lsize +LIST_INCREMENT
delete NewBase
NewBase NULL
}
ElemType *p
ElemType *temp
p &(Lelem[i1]) 取i位置插入位置
for(temp &(Lelem[Llength1])temp>ptemp) 插入点元素
移动位
{
*(temp+1) *temp
}
*p e
++Llength
return OK
}ListInsert int ListDelete(SqList &L int i ElemType &e)
{
if (i<0 || i>ListLength(L)) {
return ERROR
}
ElemType *p
p &(Lelem[i1])
e *p
ElemType *pos
pos &(Lelem[Llength1])
for(++p p*(p1) *p
}
Llength
return OK
}
#endif SQLIST_H
int main(){
SqList list
ElemType e
InitList(list)
ListInsert(list 1 1)
ListInsert(list 2 2)
ListInsert(list 3 3)
ListInsert(list 4 4)
ListInsert(list 5 5)
for(int i 0 iprintf(d\nlistelem[i])
}
ListDelete(list 2 e)
for(i 0 iprintf(d\nlistelem[i])
} printf(d\n listlength)

return 1
}

单链表逆置
#include
#include
#define NULL 0 *宏定义*
typedef struct node *定义结点类型数结构*
{
char c *数域类型字符型*
struct node *next *指针域类型结构体类型*
}Node*L *类型重定义Node*Lstruct node等价* main()
{
L lpqr *指针类型定义三结点类型指针*
char ch
l(L)malloc(sizeof(Node)) *分配存空间*
l>c'\0' *头结点数域赋值值空*
l>nextNULL *指明结点目前存*
ql *q游动指针链表结点连结*
printf(Input a character\n)
scanf(c&ch)
getchar()
while(ch'0') *输入0表示输入结束*
{
p(L)malloc(sizeof(Node)) *新输入数分配存空间*
p>cch
p>nextNULL *新输入结点链表面没元素*
q>nextp *q元素链接前新元素*
qp *q移前元素备继续链接*
scanf(c&ch)
getchar()
}
*完成单链表创建*
ql>next
pq>next
rp>next
q>nextNULL
while(rNULL)
{
p>nextq
qp
pr
if(r>nextNULL) *r面结点逆置继续*
rr>next
else
break
}
r>nextq
l>nextr 头结点指结点

ql *输入整链表前先q移链表头l般动*
while(q>nextNULL) *q指元素面元素该元素数
输出*
{
printf(c>q>next>c) *q>next>c表示q指元素数
*
qq>next *完成该元素输出q移元素重复输出操作*
}
printf(\n)
}

运动会分数统计
#include
#include
#include
#define n 4
#define m 3
#define w 2 struct achievement 定义表示成绩结构体
{int schoolnumber学校编号
char name[20] 姓名
int mark 分数
int result} struct pro 表示项目结构体
{int tag项目编号
struct achievement ach[5]
int number} struct Node
{struct pro date
struct Node *next}
void ListInitiate(struct Node * *head) 初始化单链表
{
if((*head(struct Node*)malloc(sizeof(struct Node)))NULL) exit(1)
(*head)>nextNULL
}
void main()
{
int ijt
int x[n]{0}int y[n]{0}
struct Node *head
struct Node *p
struct Node *q
ListInitiate(&head)
phead
for(i0i{
ji+1
printf(请输入第d项目信息\nj)
p>datenumberj
printf(取名次数)
scanf(d&p>datetag)
while(p>datetag3&&p>datetag5)
{printf(输入误请重新输入)
printf(取名次数)
scanf(d&p>datetag)}
t1
while(t

datetag)
{
printf(第d名名字t)
scanf(s&p>dateach[t1]name)
printf(第d名学校t)
scanf(d&p>dateach[t1]schoolnumber)
printf(第d名分数t)
scanf(d&p>dateach[t1]mark)
p>dateach[t1]resultt
t++
}
q(struct Node*)malloc(sizeof(struct Node)) 生成新结点
p>nextq
pq
p>nextNULL
}
for(i0i{
ji+1
printf(学校d成绩单\nj)
t1
phead
do
{
t1
while(t

datetag)
{
if(p>dateach[t1]schoolnumberj)
{
printf(获奖项目d p>datenumber)
printf(名次d \np>dateach[t1]result)
printf(获奖姓名s p>dateach[t1]name)
printf(分数d p>dateach[t1]mark)
if(p>datenumberx[i]x[i]+p>dateach[t1]mark
else
y[i]y[i]+p>dateach[t1]mark
}
t++
}
pp>next
}while(pNULL)
printf(\n男子团体总分d x[i])
printf(女子团体总分d \ny[i])
printf(\n团体总分d\nx[i]+y[i])
}
}

双链表
#include
#define N 10
typedef struct node
{
char name[20]
struct node *llink*rlink
}stud*双链表结构定义* *双链表创建*
stud * creat(int n)
{
stud *p*h*s
int i
if((h(stud *)malloc(sizeof(stud)))NULL)
{
printf(cannot find space\n)
exit(0)
}
h>name[0]'\0'
h>llinkNULL
h>rlinkNULL
ph
for(i0i{
if((s (stud *) malloc(sizeof(stud)))NULL)
{
printf(cannot find space\n)
exit(0)
}
p>rlinks
printf(Please input the d man's name i+1)
scanf(ss>name)
s>llinkp
s>rlinkNULL
ps
}
h>llinks
p>rlinkh
return(h)
} *查找*
stud * search(stud *hchar *x)
{
stud *p
char *y
ph>rlink
while(ph)
{
yp>name
if(strcmp(yx)0)
return(p)
else pp>rlink
}
printf(cannot find data\n)
} *印输出*
void print(stud *h)
{
stud *p
ph>rlink
printf(\nNow the double list is\n)
while(ph)
{
printf(s &*(p>name))
pp>rlink
}
printf(\n)
} *删*
void del(stud *p)
{
(p>rlink)>llinkp>llink
(p>llink)>rlinkp>rlink
free (p)
} *函数*
main()
{
int number
char studname[20]
stud *head*searchpoint
numberN
clrscr()
puts(Please input the size of the list)
scanf(d&number)
headcreat(number)
print(head)
printf(\nPlease input the name which you want to find\n)
scanf(sstudname)
searchpointsearch(headstudname)
printf(the name you want to find iss\n*&searchpoint>name)
del(searchpoint)
print(head)
puts(\n Press any key to quit)
getch()
}

约瑟夫环
#include
#include
#define N 7 定义N7表示7链表单元
#define OVERFLOW 0
#define OK 1
typedef struct LNode{ 定义链表结构
int password
int order
struct LNode *next
}LNode*LinkList int PassW[N]{3172484}
void Joseph(LinkList pint mint x) 声明函数
int main()
{
int im
LinkList Lheadpq 定义三指链表结构指针
Lhead(LinkList)malloc(sizeof(LNode)) 初始化头节点
if(Lhead)return OVERFLOW 分配空间失败返回
Lhead>passwordPassW[0]
Lhead>order1
Lhead>nextNULL
pLhead
for(i1i<7i++){
if((q(LinkList)malloc(sizeof(LNode))))return OVERFLOW
q>passwordPassW[i] 初始化循环列表中密码值
q>orderi+1
p>nextqpq 新创建指针节点p>next指pq
}
p>nextLhead p>next指头节点形成循环链表
printf(请输入第次计数值m \n)
scanf(d&m) 户输入第次计数值m
printf(第次计数值m d \nm)
Joseph(pmN)
return OK
}
void Joseph(LinkList pint mint x){
LinkList q
int i
if(x0)return 链表中没节点话立返回层函数
qp
mx mx求余求出链表中第单元求节点
if(m0)mx m刚整x令mx果m0进行
for循环样法q指删节点p指前节点样法进
行删操作
for(i1ipq
qp>next q指删节点p指q前节点
}
p>nextq>next 循环链表中删q指节点
iq>password
printf(d q>order)
free(q) 释放q指空间
Joseph(pix1)
}

图书理系统

# include
# include
# include
# include
# include # define TRUE 1
# define FALSE 0 struct member
{
int mid
char mname[20]madd[30]
struct msince
{
int daymonyear
} ms
struct mexpir
{
int daymonyear
} me } M
struct book
{
struct bkid
{
int gnobnono
} b
char bname[20]author[15]pub[20]
int price
} B
struct transaction
{
int midtid
struct bookid
{
int gnobnono
} b
struct issued
{
int daymonyear
} i struct returned
{
int daymonyear
} r float fine
char reason
} T struct date d FILE *fm*fb*ft char *mainmenu[]{
Member
Book
Reports
Help
Exit
} char *memmenu[]{
Add New Member
Renew Existing Member
Issue Duplicate ICard
Back
} char *bookmenu[]{
Add New Books
Issue Book
Return Book
Back
}
char *rptmenu[]{
Members Details
Books Details
Transactions Details
Back
} void mainscr()
void showmenu(char **menuint countint srint sc)
int getchoice(char **menuchar *hotkeysint rint cint count) void
addmember()
void renewmem()
void memdupid()
int memcheck(int id) void addbook()
void issbook()
void retbook()
int chkbook(int bnoint gnoint no) void transac1(int midchar ch)
void transac2(int midint bnoint gnoint nochar c) void allmem()
void allbook()
void alltransac() void showhelp()
**************************** MAIN
****************************************** void main()
{
int chch1ch2ch3
fmfopen(memberdata+)
ftfopen(transdata+)
fbfopen(bookdata+) mainscr() while(1)
{
bk
showmenu(mainmenu51035)
chgetchoice(mainmenuMBRHE10355)
switch(ch)
{
case 1bk1
showmenu(memmenu41035)
ch1getchoice(memmenuARIB10354)
switch(ch1)
{
case 1 addmember() goto bk1
case 2 renewmem() goto bk1
case 3 memdupid() goto bk1
case 4 goto bk
}
break
case 2bk2
showmenu(bookmenu41035)
ch2getchoice(bookmenuAIRB10354)
switch(ch2)
{
case 1 addbook() goto bk2
case 2 issbook() goto bk2
case 3 retbook() goto bk2
case 4 goto bk
}
break
case 3bk3
showmenu(rptmenu41035)
ch3getchoice(rptmenuMBTB10354)
switch(ch3)
{
case 1 allmem() goto bk3

case 2 allbook()goto bk3
case 3 alltransac()goto bk3
case 4 goto bk
}
break
case 4
showhelp() break
case 5fclose(ft) fclose(fm) fclose(fb)
exit()
}
}
}
******************** Function Do Display The Main Screen
******************* void mainscr()
{
int ij
clrscr()
textcolor(BLUE)
for(i1i<80i++)
for(j1j<24j++)
{
gotoxy(ij) cprintf()
}
textbackground(BLUE)
textcolor(LIGHTMAGENTA)
gotoxy(81)
cprintf(赏屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯
屯屯突)
gotoxy(82)
cprintf( 赏屯屯屯屯屯屯屯屯屯屯屯屯 )
gotoxy(83)
cprintf(掏屯屯屯屯屯屯屯屯屯凸 Welcome To Obaid Books 掏屯屯屯屯屯屯
屯屯)
gotoxy(84)
cprintf( 韧屯屯屯屯屯屯屯屯屯屯屯屯 )
gotoxy(85)
cprintf(韧屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯
屯屯图)
textcolor(RED)
gotoxy(110)
cprintf(Loading Files Please Wait)
textcolor(DARKGRAY)
for(i1i<81i++)
{
gotoxy(i12)
cprintf()
}
delay(200)
textcolor(LIGHTGRAY)
for(i1i<81i++)
{
gotoxy(i12)
cprintf()
delay(50)
}
textcolor(WHITE)
for(i1i<81i++)
{
gotoxy(i12)
cprintf()
delay(20)
}
textcolor(WHITE)
}
************************** The Showmenu function
***************************
void showmenu(char **menuint countint srint sc)
{
int i clrscr()
textcolor(LIGHTMAGENTA)
gotoxy(81)
cprintf(赏屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯
屯屯突)
gotoxy(82)
cprintf( 赏屯屯屯屯屯屯屯屯屯屯屯屯 )
gotoxy(83)
cprintf(掏屯屯屯屯屯屯屯屯屯凸 Welcome To Obaid Books 掏屯屯屯屯屯屯
屯屯)
gotoxy(84)
cprintf( 韧屯屯屯屯屯屯屯屯屯屯屯屯 )
gotoxy(85)
cprintf(韧屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯屯
屯屯图) for(i0i{
gotoxy(scsr++) textcolor(DARKGRAY) cprintf(menu[i])
}
}
***********************Funtion To Get User's
Choice*************************
int getchoice(char **menuchar *hotkeysint rint cint count)
{
int choice1hotkeychoice1asciiscan
char *s
while(1)
{
gotoxy(cr+choice1) textcolor(WHITE+BLINK) cprintf(menu[choice1])
while(kbhit())

asciigetch()
if(ascii0)
scangetch() gotoxy(cr+choice1) textcolor(DARKGRAY) cprintf(menu
[choice1]) if(ascii0)
{
if(scan80)
choice++ if(scan72)
choice if(choice0)

choicecount if(choice>count)
choice1
}
else
{
if(ascii13)
return(choice) shotkeys
hotkeychoice1 while(*s)
{
if(ascii*s)
return(hotkeychoice) hotkeychoice++
s++
} }
}
}
*********************Function To Add New
Members****************************
void addmember()
{
clrscr()
rewind(fm)
while( fread(&Msizeof(M)1fm)1)

Mmid+1
fseek(fm0SEEK_END)
printf(\n\t Enter Name)
fflush(stdin)gets(Mmname) Mmname[19]' ' Mmname[20]'\0'
printf(\n\t Enter Add)
fflush(stdin)gets(Mmadd) Mmadd[29]' ' Mmadd[30]'\0' getdate
(&d)
Mmsyeardda_year Mmsdaydda_day Mmsmondda_mon
MmedayMmsday MmeyearMmsyear Mmemon(Mmsmon+6)
*To Set Month After Dec To Jan*
if(Mmemon>12)
{
Mmeyear+1 Mmemon(Mmemon12)
}
*If Say The Old Date is 31122003 ie 31 Dec Then The New Date is
31062004 ie 31 Jun
But Jun consists of Only 30 days so we shall add 1 day extra so the
correct Date is 01072004 *
if(Mmeday31)
{ *Months Like AprJunSep & Nov have 30 days*
if(Mmemon4 || Mmemon6 || Mmemon9 || Mmemon11)
{
Mmeday1
Mmemon+1
} *For the Month of Feb there are 28 OR 29 days*
if(Mmemon2)
{*For Years like(199620002004 etc there are 29 days in Feb *
if( (Mmeyear4)0)
{
Mmeday3129 Mmemon+1
}
el****eday3128 Mmemon+1
}
}
}
fwrite(&Msizeof(M)1fm)
transac1(Mmid'A')
}
**********************Function To Renew A
Member****************************
void renewmem()
{
FILE *tt
int noch
clrscr()
ttfopen(temp1datw)
printf(\n\t Enter Membership Id) scanf(d&no)
chmemcheck(no)
if(chFALSE)
{
printf(\n\t No Such Member) getch() return
}
rewind(fm)
while( fread(&Msizeof(M)1fm)1 )
{
if(Mmidno)
{
Mmemon(Mmemon+6)
if(Mmemon>12 && Mmemon12)
{
Mmeyear+1 Mmemon(Mmemon12)
}
if(Mmeday31)
{
if(Mmemon4 || Mmemon6 || Mmemon9 || Mmemon11)
{
Mmeday1
Mmemon+1
}
if(Mmemon2)
{
if( (Mmeyear4)0)
{
Mmeday3129 Mmemon+1
}
el****eday3128 Mmemon+1
}
}
} fwrite(&Msizeof(M)1tt)
}
else
fwrite(&Msizeof(M)1tt)
}
fclose(tt) fclose(fm)
remove(memberdat)
rename(temp1datmemberdat)
fmfopen(memberdata+)
printf(\n\t Member Renewed)
getch()
transac1(no'E')
}
********************Function To Issue Duplicate Id
Card*********************
void memdupid()
{
int noch
clrscr()
printf(\n\t Enter Membership Id) scanf(d&no)
chmemcheck(no)
if(chFALSE)
{
printf(\n\t No Such Member) getch() return
}
printf(\n\t Duplicate ID Issued)
getch()
transac1(no'D')
}
文档香网(httpswwwxiangdangnet)户传

《香当网》用户分享的内容，不代表《香当网》观点或立场，请自行判断内容的真实性和可靠性！
该内容是文档的文本内容，更好的格式请下载文档

C语言代码大全

相关文档

C语言通讯录报告及源代码

专升本C语言题及答案

（1小时学会C语言51单片机）C语言入门教程

电脑编程所有C语言题库

技能高考专题：C语言练习

c语言实验报告

C语言作业：学通讯录

C语言上机题库WORD版

C语言试题库

c语言高级面试题

C语言知识点总结

C语言实验报告《指针》

C语言实验报告《数组》

《网页HTML中各个代码意思大全》

作文评语大全：语言简练，规范

作文评语大全：清新有趣的语言

作文评语大全：全文语言流畅

C语言论文致谢

国开电大《C语言程序设计》答案

C语言实验报告《函数》

文档贡献者

该用户的其他文档

相关PPT

相关PDF