数据结构c语言版编程电话本

1. 数据结构（c语言版）编程

约瑟夫环问题
#include<stdio.h>#include<stdlib.h>
typedef int ElemType;
typedef struct node
{
ElemType data;
struct node *next;
}slink;
void onlyone(int n);
void list(slink *head);
void onlyone(int n)
{
slink *head,*p,*q;
int i,m,k;
p=head=(slink*)malloc(sizeof(slink));
for(i=1;i<=n;i++)
{
q=(slink*)malloc(sizeof(slink));
q->data=i;
p->next=q;
p=q;
}
p->next=head;
p=head;
m=0;
while(m<n-1)
{
k=0;
while(k<3)
{
k++;q=p;p=p->next;
if(p==head)
{q=p;p=p->next;}
}
q->next=p->next;
free(p);
p=q;
m++;
}

list(head);
}
void list(slink *head)
{
slink *p;
p=head->next;
while(p!=head)
{
printf("%4d",p->data);
p=p->next;
}
printf("\n");
}
int main()
{
int a;
printf("请输入人数：");
scanf("%d",&a);
onlyone(a);
}

带头结点双向循环结点的与瑟夫环问题
#include<stdio.h>#include<stdlib.h>
typedef int ElemType;
typedef struct node
{
ElemType data;
struct node *next;
struct node *prior;
}dlink;
void onlyone(int m,int n,int k);
void list(dlink *head);
void onlyone(int m,int n,int k)
{
dlink *head,*p,*q;
int i;
if(m<1||n<1||k<1)
{printf("Error!\n");exit(0);}
p=head=(dlink*)malloc(sizeof(dlink));
for(i=1;i<=m;i++)
{
q=(dlink*)malloc(sizeof(dlink));
q->data=i;
q->prior=p;
p->next=q;
p=q;
}
p->next=head;
head->prior=p;
p=head;
while(m>1)
{
for(i=1;i<=n;i++)
{
q=p;p=p->next;
if(p==head) {q=head;p=head->next;}
}
q->next=p->next;
p->next->prior=q;
free(p);
p=q->next;
m--;
if(m>1)
{for(i=1;i<=k;i++)
{
q=p;p=p->prior;
if(p==head)
{q=p;p=p->prior;}
}
q->prior=p->prior;
p->prior->next=q;
free(p);
p=q->prior;
m--;
}
}
list(head);
}
void list(dlink *head)
{
dlink *p;
p=head->next;
while(p!=head)
{
printf("%4d",p->data);
p=p->next;
}
printf("\n");
p=head->prior;
while(p!=head)
{
printf("%4d",p->data);
p=p->prior;
}
printf("\n");
}
int main()
{
int a,b,c;
printf("请输入需要创建的自然数个数：");
scanf("%d",&a);
printf("请输入沿顺时针方向去掉的第n个数：");
scanf("%d",&b);
printf("请输入沿逆时针方向去掉的第m个数：");
scanf("%d",&c);
onlyone(a,b,c);

}

2. C语言程序设计：班级电话本管理程序

/* 电话簿程序 */
/******头文件（.h）***********/
#include "stdio.h" /*I/O函数*/
#include "stdlib.h" /*标准库函数*/
#include "string.h"/*字符串函数*/
#include "ctype.h" /*字符操作函数*/
#define M 50 /*定义常数表示记录数*/
struct unit/*定义数据结构*/
{
char name[20]; /*姓名*/
char units[30]; /*单位*/
char tele[10]; /*电话*/
};

typedef struct unit ADDRESS;

/******以下是函数原型*******/
int enter(ADDRESS t[]); /*输入记录*/
void list(ADDRESS t[],int n); /*显示记录*/
void search(ADDRESS t[],int n); /*按姓名查找显示记录*/
int delete(ADDRESS t[],int n); /*删除记录*/
int add(ADDRESS t[],int n); /*插入记录*/
void save(ADDRESS t[],int n); /*记录保存为文件*/
int load(ADDRESS t[]); /*从文件中读记录*/
void display(ADDRESS t[]); /*按序号查找显示记录*/
void sort(ADDRESS t[],int n); /*按姓名排序*/
void qseek(ADDRESS t[],int n); /*快速查找记录*/
void (); /*文件复制*/
void print(ADDRESS temp); /*显示单条记录*/
int find(ADDRESS t[],int n,char *s) ; /*查找函数*/
int menu_select(); /*主菜单函数*/

/******主函数开始*******/
main()
{
int i;
ADDRESS adr[M]; /*定义结构体数组*/
int length; /*保存记录长度*/
clrscr(); /*清屏*/
for(;;)/*无限循环*/
{
switch(menu_select()) /*调用主菜单函数，返回值整数作开关语句的条件*/
{
case 0:length=enter(adr);break;/*输入记录*/
case 1:list(adr,length);break; /*显示全部记录*/
case 2:search(adr,length);break; /*查找记录*/
case 3:length=delete(adr,length);break; /*删除记录*/
case 4:length=add(adr,length); break; /*插入记录*/
case 5:save(adr,length);break; /*保存文件*/
case 6:length=load(adr); break; /*读文件*/
case 7:display(adr);break; /*按序号显示记录*/
case 8:sort(adr,length);break; /*按姓名排序*/
case 9:qseek(adr,length);break; /*快速查找记录*/
case 10:();break; /*复制文件*/
case 11:exit(0); /*如返回值为11则程序结束*/
}
}
}
/*菜单函数，函数返回值为整数，代表所选的菜单项*/
menu_select()
{
char s[80];
int c;
gotoxy(1,25);/*将光标定为在第25行，第1列*/
printf("press any key enter menu......\n");/*提示压任意键继续*/
getch(); /*读入任意字符*/
clrscr(); /*清屏*/
gotoxy(1,1);
printf("********************MENU*********************\n\n");
printf(" 0. Enter record\n");
printf(" 1. List the file\n");
printf(" 2. Search record on name\n");
printf(" 3. Delete a record\n");
printf(" 4. add record \n");
printf(" 5. Save the file\n");
printf(" 6. Load the file\n");
printf(" 7. display record on order\n");
printf(" 8. sort to make new file\n");
printf(" 9. Quick seek record\n");
printf(" 10. the file to new file\n");
printf(" 11. Quit\n");
printf("***********************************************\n");
do{
printf("\n Enter you choice(0~11):"); /*提示输入选项*/
scanf("%s",s); /*输入选择项*/
c=atoi(s); /*将输入的字符串转化为整型数*/
}while(c<0||c>11); /*选择项不在0~11之间重输*/
return c; /*返回选择项，主程序根据该数调用相应的函数*/
}
/***输入记录，形参为结构体数组，函数值返回类型为整型表示记录长度*/
int enter(ADDRESS t[])
{
int i,n;
char *s;
clrscr(); /*清屏*/
printf("\nplease input num \n"); /*提示信息*/
scanf("%d",&n); /*输入记录数*/
printf("please input record \n"); /*提示输入记录*/
printf("name unit telephone\n");
printf("------------------------------------------------\n");
for(i=0;i<n;i++)
{
scanf("%s%s%s",t[i].name,t[i].units,t[i].tele); /*输入记录*/
printf("----------------------------------------------\n");
}
return n; /*返回记录条数*/
}
/*显示记录，参数为记录数组和记录条数*/
void list(ADDRESS t[],int n)
{
int i;
clrscr();
printf("\n\n*******************ADDRESS******************\n");
printf("name unit telephone\n");
printf("------------------------------------------------\n");
for(i=0;i<n;i++)
printf("%-20s%-30s%-10s\n",t[i].name,t[i].units,t[i].tele);
if((i+1)%10==0) /*判断输出是否达到10条记录*/
{
printf("Press any key continue...\n"); /*提示信息*/
getch(); /*压任意键继续*/
}
printf("************************end*******************\n");
}
/*查找记录*/
void search(ADDRESS t[],int n)
{
char s[20]; /*保存待查找姓名字符串*/
int i; /*保存查找到结点的序号*/
clrscr(); /*清屏*/
printf("please search name\n");
scanf("%s",s); /*输入待查找姓名*/
i=find(t,n,s); /*调用find函数，得到一个整数*/
if(i>n-1) /*如果整数i值大于n-1，说明没找到*/
printf("not found\n");
else
print(t[i]); /*找到，调用显示函数显示记录*/
}
/*显示指定的一条记录*/
void print(ADDRESS temp)
{
clrscr();
printf("\n\n********************************************\n");
printf("name unit telephone\n");
printf("------------------------------------------------\n");
printf("%-20s%-30s%-10s\n",temp.name,temp.units,temp.tele);
printf("**********************end***********************\n");
}
/*查找函数，参数为记录数组和记录条数以及姓名s */
int find(ADDRESS t[],int n,char *s)
{
int i;
for(i=0;i<n;i++)/*从第一条记录开始，直到最后一条*/
{
if(strcmp(s,t[i].name)==0) /*记录中的姓名和待比较的姓名是否相等*/
return i; /*相等，则返回该记录的下标号，程序提前结结束*/
}
return i; /*返回i值*/
}
/*删除函数，参数为记录数组和记录条数*/
int delete(ADDRESS t[],int n)
{
char s[20]; /*要删除记录的姓名*/
int ch=0;
int i,j;
printf("please deleted name\n"); /*提示信息*/
scanf("%s",s);/*输入姓名*/
i=find(t,n,s); /*调用find函数*/
if(i>n-1) /*如果i>n-1超过了数组的长度*/
printf("no found not deleted\n"); /*显示没找到要删除的记录*/
else
{
print(t[i]); /*调用输出函数显示该条记录信息*/
printf("Are you sure delete it(1/0)\n"); /*确认是否要删除*/
scanf("%d",&ch); /*输入一个整数0或1*/
if(ch==1) /*如果确认删除整数为1*/
{
for(j=i+1;j<n;j++) /*删除该记录，实际后续记录前移*/
{
strcpy(t[j-1].name,t[j].name); /*将后一条记录的姓名拷贝到前一条*/
strcpy(t[j-1].units,t[j].units); /*将后一条记录的单位拷贝到前一条*/
strcpy(t[j-1].tele,t[j].tele); /*将后一条记录的电话拷贝到前一条*/
}
n--; /*记录数减1*/
}
}
return n; /*返回记录数*/
}
/*插入记录函数，参数为结构体数组和记录数*/
int add(ADDRESS t[],int n)/*插入函数，参数为结构体数组和记录数*/
{
ADDRESS temp; /*新插入记录信息*/
int i,j;
char s[20]; /*确定插入在哪个记录之前*/
printf("please input record\n");
printf("************************************************\n");
printf("name unit telephone\n");
printf("--------------------------------------------------\n");
scanf("%s%s%s",temp.name,temp.units,temp.tele); /*输入插入信息*/
printf("------------------------------------------------\n");
printf("please input locate name \n");
scanf("%s",s); /*输入插入位置的姓名*/
i=find(t,n,s); /*调用find，确定插入位置*/
for(j=n-1;j>=i;j--) /*从最后一个结点开始向后移动一条*/
{
strcpy(t[j+1].name,t[j].name); /*当前记录的姓名拷贝到后一条*/
strcpy(t[j+1].units,t[j].units); /*当前记录的单位拷贝到后一条*/
strcpy(t[j+1].tele,t[j].tele); /*当前记录的电话拷贝到后一条*/
}
strcpy(t[i].name,temp.name); /*将新插入记录的姓名拷贝到第i个位置*/
strcpy(t[i].units,temp.units); /*将新插入记录的单位拷贝到第i个位置*/
strcpy(t[i].tele,temp.tele); /*将新插入记录的电话拷贝到第i个位置*/
n++; /*记录数加1*/
return n; /*返回记录数*/
}
/*保存函数，参数为结构体数组和记录数*/
void save(ADDRESS t[],int n)
{
int i;
FILE *fp; /*指向文件的指针*/
if((fp=fopen("record.txt","wb"))==NULL) /*打开文件，并判断打开是否正常*/
{
printf("can not open file\n");/*没打开*/
exit(1); /*退出*/
}
printf("\nSaving file\n"); /*输出提示信息*/
fprintf(fp,"%d",n); /*将记录数写入文件*/
fprintf(fp,"\r\n"); /*将换行符号写入文件*/
for(i=0;i<n;i++)
{
fprintf(fp,"%-20s%-30s%-10s",t[i].name,t[i].units,t[i].tele);/*格式写入记录*/
fprintf(fp,"\r\n"); /*将换行符号写入文件*/
}
fclose(fp);/*关闭文件*/
printf("****save success***\n"); /*显示保存成功*/
}
/*读入函数，参数为结构体数组*/
int load(ADDRESS t[])
{
int i,n;
FILE *fp; /*指向文件的指针*/
if((fp=fopen("record.txt","rb"))==NULL)/*打开文件*/
{
printf("can not open file\n"); /*不能打开*/
exit(1); /*退出*/
}
fscanf(fp,"%d",&n); /*读入记录数*/
for(i=0;i<n;i++)
fscanf(fp,"%20s%30s%10s",t[i].name,t[i].units,t[i].tele); /*按格式读入记录*/
fclose(fp); /*关闭文件*/
printf("You have success read data from file!!!\n"); /*显示保存成功*/
return n; /*返回记录数*/
}
/*按序号显示记录函数*/
void display(ADDRESS t[])
{
int id,n;
FILE *fp; /*指向文件的指针*/
if((fp=fopen("record.txt","rb"))==NULL) /*打开文件*/
{
printf("can not open file\n"); /*不能打开文件*/
exit(1); /*退出*/
}
printf("Enter order number...\n"); /*显示信息*/
scanf("%d",&id); /*输入序号*/
fscanf(fp,"%d",&n); /*从文件读入记录数*/
if(id>=0&&id<n) /*判断序号是否在记录范围内*/
{
fseek(fp,(id-1)*sizeof(ADDRESS),1); /*移动文件指针到该记录位置*/
print(t[id]); /*调用输出函数显示该记录*/
printf("\r\n");
}
else
printf("no %d number record!!!\n ",id); /*如果序号不合理显示信息*/
fclose(fp); /*关闭文件*/
}
/*排序函数，参数为结构体数组和记录数*/
void sort(ADDRESS t[],int n)
{
int i,j,flag;
ADDRESS temp; /*临时变量做交换数据用*/
for(i=0;i<n;i++)
{
flag=0; /*设标志判断是否发生过交换*/
for(j=0;j<n-1;j++)
if((strcmp(t[j].name,t[j+1].name))>0) /*比较大小*/
{
flag=1;
strcpy(temp.name,t[j].name); /*交换记录*/
strcpy(temp.units,t[j].units);
strcpy(temp.tele,t[j].tele);
strcpy(t[j].name,t[j+1].name);
strcpy(t[j].units,t[j+1].units);
strcpy(t[j].tele,t[j+1].tele);
strcpy(t[j+1].name,temp.name);
strcpy(t[j+1].units,temp.units);
strcpy(t[j+1].tele,temp.tele);
}
if(flag==0)break; /*如果标志为0，说明没有发生过交换循环结束*/
}
printf("sort sucess!!!\n"); /*显示排序成功*/
}
/*快速查找，参数为结构体数组和记录数*/
void qseek(ADDRESS t[],int n)
{
char s[20];
int l,r,m;
printf("\nPlease sort before qseek!\n"); /*提示确认在查找之前，记录是否已排序*/
printf("please enter name for qseek\n"); /*提示输入*/
scanf("%s",s); /*输入待查找的姓名*/
l=0;r=n-1; /*设置左边界与右边界的初值*/
while(l<=r) /*当左边界<=右边界时*/
{
m=(l+r)/2; /*计算中间位置*/
if(strcmp(t[m].name,s)==0) /*与中间结点姓名字段做比较判是否相等*/
{
print(t[m]); /*如果相等，则调用print函数显示记录信息*/
return ; /*返回*/
}
if(strcmp(t[m].name,s)<0) /*如果中间结点小*/
l=m+1; /*修改左边界*/
else
r=m-1; /*否则，中间结点大，修改右边界*/
}
if(l>r) /*如果左边界大于右边界时*/
printf("not found\n"); /*显示没找到*/
}
/*复制文件*/
void ()
{
char outfile[20]; /*目标文件名*/
int i,n;
ADDRESS temp[M]; /*定义临时变量*/
FILE *sfp,*tfp; /*定义指向文件的指针*/
clrscr();/*清屏*/
if((sfp=fopen("record.txt","rb"))==NULL) /*打开记录文件*/
{
printf("can not open file\n"); /*显示不能打开文件信息*/
exit(1); /*退出*/
}
printf("Enter outfile name,for example c:\\f1\\te.txt:\n"); /*提示信息*/
scanf("%s",outfile); /*输入目标文件名*/
if((tfp=fopen(outfile,"wb"))==NULL) /*打开目标文件*/
{
printf("can not open file\n"); /*显示不能打开文件信息*/
exit(1); /*退出*/
}
fscanf(sfp,"%d",&n); /*读出文件记录数*/
fprintf(tfp,"%d",n);/*写入目标文件数*/
fprintf(tfp,"\r\n"); /*写入换行符*/
for(i=0;i<n;i++)
{
fscanf(sfp,"%20s%30s%10s\n",temp[i].name,temp[i].units,
temp[i].tele); /*读入记录*/
fprintf(tfp,"%-20s%-30s%-10s\n",temp[i].name,
temp[i].units,temp[i].tele); /*写入记录*/
fprintf(tfp,"\r\n"); /*写入换行符*/
}
fclose(sfp); /*关闭源文件*/
fclose(tfp); /*关闭目标文件*/
printf("you have success file!!!\n"); /*显示复制成功*/
}


3. 《数据结构（C语言版）》pdf下载在线阅读，求百度网盘云资源

《数据结构（C语言版）》（严蔚敏）电子书网盘下载免费在线阅读

资源链接：

链接：https://pan..com/s/1BmtD5k3mLtJZO36Xw_Hq3w

书名：数据结构（C语言版）

作者：严蔚敏

豆瓣评分：6.1

出版社：清华大学出版社

出版年份：2012-5

页数：335

内容简介：

《数据结构》（C语言版）是为“数据结构”课程编写的教材，也可作为学习数据结构及其算法的C程序设计的参数教材。

本书的前半部分从抽象数据类型的角度讨论各种基本类型的数据结构及其应用；后半部分主要讨论查找和排序的各种实现方法及其综合分析比较。其内容和章节编排1992年4月出版的《数据结构》（第二版）基本一致，但在本书中更突出了抽象数据类型的概念。全书采用类C语言作为数据结构和算法的描述语言。

本书概念表述严谨，逻辑推理严密，语言精炼，用词达意，并有配套出版的《数据结构题集》（C语言版），便于教学，又便于自学。

本书后附有光盘。光盘内容可在DOS环境下运行的以类C语言描述的“数据结构算法动态模拟辅助教学软件，以及在Windows环境下运行的以类PASCAL或类C两种语言描述的“数据结构算法动态模拟辅助教学软件”。

本书可作为计算机类专业或信息类相关专业的本科或专科教材，也可供从事计算机工程与应用工作的科技工作者参考。

作者简介：

严蔚敏 清华大学计算机系教授，长期从事数据结构教学和教材建设，和吴伟民合作编着的《数据结构》曾获“第二届普通高等学校优秀教材全国特等奖”和“1996年度国家科学技术进步奖三等奖”。

吴伟民 广东工业大学计算机学院副教授，硕士生导师。广东省计算机学会图像图形分会秘书长。长期从事数据结构教学和系列教材建设。主要研究领域：数据结构和算法、可是计算、编译和虚拟机技术、智能系统等。和严蔚敏合作编着的《数据结构》曾获“第二届普通高等学校优秀教材全国特等奖”和“1996年度国家科学技术进步奖三等奖”。

4. 数据结构编程C语言版

void PrintMaze(MazeType &maze)
{//将标记路径信息的迷宫输出到终端(包括外墙)
int i,j,n,k;
n = (34 - maze.c)/2;
for(k=0; k<n; k++)//让迷宫居中
printf(" ");
printf(" ");
for(i=0;i<=maze.c+1;i++)//打印列数名
{
printf("%2d",i);
if(i==9) //对齐
printf(" ");
}
printf("\n");
for(i=0;i<=maze.r+1;i++)
{
for(k=0; k<n; k++)//让迷宫居中
printf(" ");
printf("%2d",i); //打印行名
for(j=0;j<=maze.c+1;j++)
{
switch(maze.adr[i][j])
{
case ' ':
printf(" ");//路
break;
case '#':
printf("■"); //墙
break;
case '*':
printf(". ");//路径
break;
case '@':
printf("◇");//走过两次的地方
break;
case 'e':
printf("E ");//结束位置
break;
case 's':
printf("S ");//开始位置
break;
case '!':
printf("♀");//人
break;
default:
printf("? "); //出错
}
}
printf("\n");
}
}

Status NextPosPlay(MazeType &maze, PostType &curpos)
{
//指示并返回下一位置的坐标
char c; //接收用户输入的方向
printf("\n请输入'w'(上)、's'(下)、'a'(左)、'd'(右)<回到出发点和输入'H/h'可以寻求电脑帮助>");
do{
c = getch();
}while(c!='w'&&c!='s'&&c!='a'&&c!='d'&&c!='h'&&c!='W'&&c!='S'&&c!='A'&&c!='D'&&c!='H');
switch(c)
{
case 'd': //右
case 'D':
curpos.c += 1;
break;
case 's': //下
case 'S':
curpos.r += 1;
break;
case 'a': //左
case 'A':
curpos.c -= 1;
break;
case 'w': //上
case 'W':
curpos.r -= 1;
break;
case 'h': //推出，让电脑帮助
case 'H':
return FALSE;
}
return OK;
}

Status PlayMazePath(MazeType &maze, PostType start, PostType end)
{
PostType curpos, w; //curpos为当前步，w为上一步；
SElemType e; //堆栈存储类型
curpos = start; //设置"当前位置"为"入口位置"
Stack S; //存储走过的最简路径
InitStack(S);
do
{
if(Pass(maze, curpos)) //如果可以通过
{
maze.adr[curpos.r][curpos.c] = '!'; //'！'表示人，设置当前步为人，方便动态显示
system("cls"); //清屏
PrintMaze(maze); //动态输出迷宫路径
maze.adr[curpos.r][curpos.c] = ' '; //还原
w = curpos;
e.seat = curpos;
Push(S, e);
DeleteSameElem(S); //删除重复的步子
if(!NextPosPlay(maze, curpos)) //接收下一步
{
return FALSE; //退出 让电脑帮助
}
}
else
{
curpos = w; //退回到上一步
if(!NextPosPlay(maze, curpos)) //接收下一步
{
return FALSE; //退出 让电脑帮助
}
}
if(curpos.r == start.r && curpos.c == start.c) //若当前为出口则让电脑帮助
{
return FALSE; //退出
}
}while(curpos.r != end.r || curpos.c != end.c);//当前位置为结束位置时推出循环

maze.adr[curpos.r][curpos.c] = '!'; //设置当前步为人，方便动态显示
system("cls");
while(!StackEmpty(S)) //把存储的步子放入数组
{
Pop(S,e);
maze.adr[e.seat.r][e.seat.c] = '*'; //设置路径， ‘*’表示路径
}
PrintMaze(maze); //输出带有路径的迷宫
printf("\n\t\t这是你走过的最短路径");
return OK;
}

void PlayMaze()
{
MazeType maze;
char c; //接收用户输入的选择
PostType start, end; //开始和结束点
int n, flag=1,m; //n表示系统迷宫和随机迷宫 m表示难度
system("cls");
printf("\n\n\n ┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴\n");
printf(" ┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬\n");
printf(" ┬┴┬ 1:使用系统默认迷宫 ┬┴┬\n");
printf(" ┴┬┴ 2:使用随机产生迷宫 ┴┬┴\n");
printf(" ┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬\n");
printf(" ┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴┬┴\n\n");
printf("请选择：");
do{
scanf("%d", &n);
}while(n!=1 && n!=2); //选择系统迷宫或随机迷宫
if(n == 2) //选择随机迷宫
{
RandomInitMaze(maze); //调用随机产生迷宫的函数
system("cls");
PrintMaze(maze);
InputBeginEnd(maze, start, end); //输入开始和结束点
}
else //选择自带的迷宫
{
m = SetMaze(maze); //调用设置自带迷宫的函数
if(m == 1) //初级
{
start.r = 1; start.c = 1;
end.r = 9; end.c = 10;
}
else if(m == 2) //中级
{
start.r = 1; start.c = 1;
end.r = 15; end.c = 15;
}
else if(m == 3) //高级
{
start.r = 1; start.c = 1;
end.r = 20; end.c = 26;
}
maze.adr[start.r][start.c] = 's';
maze.adr[end.r][end.c] = 'e'; //把开始结束点显示给用户
PrintMaze(maze);
printf("\n\t'S'表示出发点，'E'表示终止点");
printf("\n\t<请按任意键>");
getch();
}

while(flag){
if(!PlayMazePath(maze, start, end))//迷宫求解
{
printf("\n请问你需要电脑帮你吗？(y/n):\n");
do{
c = getchar();
}while(c != 'y' && c != 'Y' && c != 'n' && c != 'N'); //接收用户是否需要电脑帮助
if(c == 'y' || c == 'Y') //需要帮助
{
if(!MazePath(maze, start, end)) //电脑计算
printf("\n\t\t没有路径！\n");
flag = 0;
}
else //不需要帮助 自己继续找路径
{
flag = 1;
}
}
else //找到路径
{
printf("\n\t\t\tGood!你找到了路径！\n");
flag = 0;
}
}
}

5. 数据结构（c语言版）编程求助

就是队列的知识吧，设计4个队就行了。

6. C语言程序设计 建立通信录

#include "stdio.h" /*I/O函数*/
#include "stdlib.h" /*其它说明*/
#include "string.h" /*字符串函数*/
#include "conio.h" /*屏幕操作函数*/
#include "mem.h" /*内存操作函数*/
#include "ctype.h" /*字符操作函数*/
#include "alloc.h" /*动态地址分配函数*/
#define N 3 /*定义常数*/
typedef struct z1 /*定义数据结构*/
{
char no[11];
char name[15];
int score[N];
float sum;
float average;
int order;
struct z1 *next;
}STUDENT;
/*以下是函数原型*/
STUDENT *init(); /*初始化函数*/
STUDENT *create(); /*创建链表*/
STUDENT *delete(STUDENT *h); /*删除记录*/
void print(STUDENT *h); /* 显示所有记录*/
void search(STUDENT *h); /*查找*/
void save(STUDENT *h); /*保存*/
STUDENT *load(); /*读入记录*/
void computer(STUDENT *h); /*计算总分和均分*/
STUDENT *insert(STUDENT *h); /*插入记录*/
void append(); /*追加记录*/
void (); /*复制文件*/
STUDENT *sort(STUDENT *h); /*排序*/
STUDENT *index(STUDENT *h); /*索引*/
void total(STUDENT *h); /*分类合计*/
int menu_select(); /*菜单函数*/
/******主函数开始*******/
main()
{
int i;
STUDENT *head; /*链表定义头指针*/
head=init(); /*初始化链表*/
clrscr(); /*清屏*/
for(;;) /*无限循环*/
{
switch(menu_select()) /*调用主菜单函数，返回值整数作开关语句的条件*/
{ /*值不同，执行的函数不同，break 不能省略*/
case 0:head=init();break; /*执行初始化*/
case 1:head=create();break; /*创建链表*/
case 2:head=delete(head);break; /*删除记录*/
case 3:print(head);break; /*显示全部记录*/
case 4:search(head);break; /*查找记录*/
case 5:save(head);break; /*保存文件*/
case 6:head=load(); break; /*读文件*/
case 7:computer(head);break; /*计算总分和均分*/
case 8:head=insert(head); break; /*插入记录*/
case 9:();break; /*复制文件*/
case 10:head=sort(head);break; /*排序*/
case 11:append();break; /*追加记录*/
case 12:head=index(head);break; /*索引*/
case 13:total(head);break; /*分类合计*/
case 14:exit(0); /*如菜单返回值为14程序结束*/
}
}
}
/*菜单函数，返回值为整数*/
menu_select()
{
char *menu[]={"***************MENU***************", /*定义菜单字符串数组*/
" 0. init list", /*初始化*/
" 1. Enter list", /*输入记录*/
" 2. Delete a record from list", /*从表中删除记录*/
" 3. print list ", /*显示单链表中所有记录*/
" 4. Search record on name", /*按照姓名查找记录*/
" 5. Save the file", /*将单链表中记录保存到文件中*/
" 6. Load the file", /*从文件中读入记录*/
" 7. compute the score", /*计算所有学生的总分和均分*/
" 8. insert record to list ", /*插入记录到表中*/
" 9. the file to new file", /*复制文件*/
" 10. sort to make new file", /*排序*/
" 11. append record to file", /*追加记录到文件中*/
" 12. index on nomber", /*索引*/
" 13. total on nomber", /*分类合计*/
" 14. Quit"}; /*退出*/
char s[3]; /*以字符形式保存选择号*/
int c,i; /*定义整形变量*/
gotoxy(1,25); /*移动光标*/
printf("press any key enter menu......\n"); /*压任一键进入主菜单*/
getch(); /*输入任一键*/
clrscr(); /*清屏幕*/
gotoxy(1,1); /*移动光标*/
textcolor(YELLOW); /*设置文本显示颜色为黄色*/
textbackground(BLUE); /*设置背景颜色为蓝色*/
gotoxy(10,2); /*移动光标*/
putch(0xc9); /*输出左上角边框┏*/
for(i=1;i<44;i++)
putch(0xcd); /*输出上边框水平线*/
putch(0xbb); /*输出右上角边框 ┓*/
for(i=3;i<20;i++)
{
gotoxy(10,i);putch(0xba); /*输出左垂直线*/
gotoxy(54,i);putch(0xba);
} /*输出右垂直线*/
gotoxy(10,20);putch(0xc8); /*输出左上角边框┗*/
for(i=1;i<44;i++)
putch(0xcd); /*输出下边框水平线*/
putch(0xbc); /*输出右下角边框┛*/
window(11,3,53,19); /* 制作显示菜单的窗口，大小根据菜单条数设计*/
clrscr(); /*清屏*/
for(i=0;i<16;i++) /*输出主菜单数组*/
{
gotoxy(10,i+1);
cprintf("%s",menu[i]);
}
textbackground(BLACK); /*设置背景颜色为黑色*/
window(1,1,80,25); /*恢复原窗口大小*/
gotoxy(10,21); /*移动光标*/
do{
printf("\n Enter you choice(0~14):"); /*在菜单窗口外显示提示信息*/
scanf("%s",s); /*输入选择项*/
c=atoi(s); /*将输入的字符串转化为整形数*/
}while(c<0||c>14); /*选择项不在0~14之间重输*/
return c; /*返回选择项，主程序根据该数调用相应的函数*/
}
STUDENT *init()
{
return NULL;
}

/*创建链表*/
STUDENT *create()
{
int i; int s;
STUDENT *h=NULL,*info; /* STUDENT指向结构体的指针*/
for(;;)
{
info=(STUDENT *)malloc(sizeof(STUDENT)); /*申请空间*/
if(!info) /*如果指针info为空*/
{
printf("\nout of memory"); /*输出内存溢出*/
return NULL; /*返回空指针*/
}
inputs("enter no:",info->no,11); /*输入学号并校验*/
if(info->no[0]=='@') break; /*如果学号首字符为@则结束输入*/
inputs("enter name:",info->name,15); /*输入姓名，并进行校验*/
printf("please input %d score \n",N); /*提示开始输入成绩*/
s=0; /*计算每个学生的总分，初值为0*/
for(i=0;i<N;i++) /*N门课程循环N次*/
{
do{
printf("score%d:",i+1); /*提示输入第几门课程*/
scanf("%d",&info->score[i]); /*输入成绩*/
if(info->score[i]>100||info->score[i]<0) /*确保成绩在0~100之间*/
printf("bad data,repeat input\n"); /*出错提示信息*/
}while(info->score[i]>100||info->score[i]<0);
s=s+info->score[i]; /*累加各门课程成绩*/
}
info->sum=s; /*将总分保存*/
info->average=(float)s/N; /*求出平均值*/
info->order=0; /*未排序前此值为0*/
info->next=h; /*将头结点做为新输入结点的后继结点*/
h=info; /*新输入结点为新的头结点*/
}
return(h); /*返回头指针*/
}
/*输入字符串，并进行长度验证*/
inputs(char *prompt, char *s, int count)
{
char p[255];
do{
printf(prompt); /*允鞠提示信息*/
scanf("%s",p); /*输入字符串*/
if(strlen(p)>count)printf("\n too long! \n"); /*进行长度校验，超过count值重输入*/
}while(strlen(p)>count);
strcpy(s,p); /*将输入的字符串拷贝到字符串s中*/
}
/*输出链表中结点信息*/
void print(STUDENT *h)
{
int i=0; /* 统计记录条数*/
STUDENT *p; /*移动指针*/
clrscr(); /*清屏*/
p=h; /*初值为头指针*/
printf("\n\n\n****************************STUDENT********************************\n");
printf("|rec|nO | name | sc1| sc2| sc3| sum | ave |order|\n");
printf("|---|----------|---------------|----|----|----|--------|-------|-----|\n");
while(p!=NULL)
{
i++;
printf("|%3d |%-10s|%-15s|%4d|%4d|%4d| %4.2f | %4.2f | %3d |\n", i, p->no,p->name,p->score[0],p->score[1],
p->score[2],p->sum,p->average,p->order);
p=p->next;
}
printf("**********************************end*********************************\n");
}

/*删除记录*/
STUDENT *delete(STUDENT *h)
{
STUDENT *p,*q; /*p为查找到要删除的结点指针，q为其前驱指针*/
char s[11]; /*存放学号*/
clrscr(); /*清屏*/
printf("please deleted no\n"); /*显示提示信息*/
scanf("%s",s); /*输入要删除记录的学号*/
q=p=h; /*给q和p赋初值头指针*/
while(strcmp(p->no,s)&&p!=NULL) /*当记录的学号不是要找的，或指针不为空时*/
{
q=p; /*将p指针值赋给q作为p的前驱指针*/
p=p->next; /*将p指针指向下一条记录*/
}
if(p==NULL) /*如果p为空，说明链表中没有该结点*/
printf("\nlist no %s student\n",s);
else /*p不为空，显示找到的记录信息*/
{
printf("*****************************have found***************************\n");
printf("|no | name | sc1| sc2| sc3| sum | ave |order|\n");
printf("|----------|---------------|----|----|----|--------|-------|-----|\n");
printf("|%-10s|%-15s|%4d|%4d|%4d| %4.2f | %4.2f | %3d |\n", p->no,
p->name,p->score[0],p->score[1],p->score[2],p->sum,
p->average,p->order);
printf("********************************end*******************************\n");
getch(); /*压任一键后，开始删除*/
if(p==h) /*如果p==h，说明被删结点是头结点*/
h=p->next; /*修改头指针指向下一条记录*/
else
q->next=p->next; /*不是头指针，将p的后继结点作为q的后继结点*/
free(p); /*释放p所指结点空间*/
printf("\n have deleted No %s student\n",s);
printf("Don't forget save\n");/*提示删除后不要忘记保存文件*/
}
return(h); /*返回头指针*/
}
/*查找记录*/
void search(STUDENT/*当记录的姓名不是要找的，或指针不为空时*/
{ p=p->next; /*移动指针，指向下一结点*/
if(p==NULL) /*如果指针为空*/
printf("\nlist no %s student\n",s); /*显示没有该学生*/
else /*显示找到的记录信息*/
{
printf （*h)
{
STUDENT *p; /* 移动指针*/
char s[15]; /*存放姓名的字符数组*/
clrscr(); /*清屏幕*/
printf("please enter name for search\n");
scanf("%s",s); /*输入姓名*/
p=h; /*将头指针赋给p*/
while(strcmp(p->name,s)&&p!=NULL) ("\n\n*****************************havefound***************************\n");
printf("|nO | name | sc1| sc2| sc3| sum | ave |order|\n");
printf("|----------|---------------|----|----|----|--------|-------|-----|\n");
printf("|%-10s|%-15s|%4d|%4d|%4d| %4.2f | %4.2f | %3d |\n", p->no,
p->name,p->score[0],p->score[1],p->score[2],p->sum,p->average,p->order);
printf("********************************end*******************************\n");
}
}
}
/*插入记录*/
STUDENT *insert(STUDENT *h)
{
STUDENT *p,*q,*info; /*p指向插入位置，q是其前驱，info指新插入记录*/
char s[11]; /*保存插入点位置的学号*/
int s1,i;
printf("please enter location before the no\n");
scanf("%s",s); /*输入插入点学号*/
printf("\nplease new record\n"); /*提示输入记录信息*/
info=(STUDENT *)malloc(sizeof(STUDENT)); /*申请空间*/
if(!info)
{
printf("\nout of memory"); /*如没有申请到，内存溢出*/
return NULL; /*返回空指针*/
}
inputs("enter no:",info->no,11); /*输入学号*/
inputs("enter name:",info->name,15); /*输入姓名*/
printf("please input %d score \n",N); /*提示输入分数*/
s1=0; /*保存新记录的总分，初值为0*/
for(i=0;i<N;i++) /*N门课程循环N次输入成绩*/
{
do{ /*对数据进行验证，保证在0~100之间*/

printf("score%d:",i+1);
scanf("%d",&info->score[i]);
if(info->score[i]>100||info->score[i]<0)
printf("bad data,repeat input\n");
}while(info->score[i]>100||info->score[i]<0);
s1=s1+info->score[i]; /*计算总分*/
}
info->sum=s1; /*将总分存入新记录中*/
info->average=(float)s1/N; /*计算均分*/
info->order=0; /*名次赋值0*/
info->next=NULL; /*设后继指针为空*/
p=h; /*将指针赋值给p*/
q=h; /*将指针赋值给q*/
while(strcmp(p->no,s)&&p!=NULL) /*查找插入位置*/
{
q=p; /*保存指针p，作为下一个p的前驱*/
p=p->next; /*将指针p后移*/
}
if(p==NULL) /*如果p指针为空，说明没有指定结点*/
if(p==h) /*同时p等于h，说明链表为空*/
h=info; /*新记录则为头结点*/
else
q->next=info; /*p为空，但p不等于h，将新结点插在表尾*/
else
if(p==h) /*p不为空，则找到了指定结点*/
{
info->next=p; /*如果p等于h，则新结点插入在第一个结点之前*/
h=info; /*新结点为新的头结点*/
}
else
{
info->next=p; /*不是头结点，则是中间某个位置，新结点的后继为p*/
q->next=info; /*新结点作为q的后继结点*/
}
printf("\n ----have inserted %s student----\n",info->name); printf("---Don't forget save---\n"); /*提示存盘*/
return(h); /*返回头指针*/
}
/*保存数据到文件*/
void save(STUDENT *h)
{
FILE *fp; /*定义指向文件的指针*/
STUDENT *p; /* 定义移动指针*/
char outfile[10]; /*保存输出文件名*/
printf("Enter outfile name,for example c:\\f1\\te.txt:\n"); /*提示文件名格式信息*/
scanf("%s",outfile);
if((fp=fopen(outfile,"wb"))==NULL) /*为输出打开一个二进制文件，如没有则建立*/
{
printf("can not open file\n");
exit(1);
}
printf("\nSaving file......\n"); /*打开文件，提示正在保存*/
p=h; /*移动指针从头指针开始*/
while(p!=NULL) /*如p不为空*/
{
fwrite(p,sizeof(STUDENT),1,fp);/*写入一条记录*/
p=p->next; /*指针后移*/
}
fclose(fp); /*关闭文件*/
printf("-----save success!!-----\n"); /*显示保存成功*/
}
/* 从文件读数据*/
STUDENT *load()
{
STUDENT *p,*q,*h=NULL; /*定义记录指针变量*/
FILE *fp; /* 定义指向文件的指针*/
char infile[10]; /*保存文件名*/
printf("Enter infile name,for example c:\\f1\\te.txt:\n"); scanf("%s",infile); /*输入文件名*/
if((fp=fopen(infile,"rb"))==NULL) /*打开一个二进制文件，为读方式*/
{
printf("can not open file\n"); /*如不能打开，则结束程序*/
exit(1);
}
printf("\n -----Loading file!-----\n");
p=(STUDENT *)malloc(sizeof(STUDENT)); /*申请空间*/
if(!p)
{
printf("out of memory!\n"); /*如没有申请到，则内存溢出*/
return h; /*返回空头指针*/
}
h=p; /*申请到空间，将其作为头指针*/
while(!feof(fp)) /*循环读数据直到文件尾结束*/
{
if(1!=fread(p,sizeof(STUDENT),1,fp))
break; /*如果没读到数据，跳出循环*/
p->next=(STUDENT *)malloc(sizeof(STUDENT)); /*为下一个结点申请空间*/
if(!p->next)
{
printf("out of memory!\n"); /*如没有申请到，则内存溢出*/
return h;
}
q=p; /*保存当前结点的指针，作为下一结点的前驱*/
p=p->next; /*指针后移，新读入数据链到当前表尾*/
}
q->next=NULL; /*最后一个结点的后继指针为空*/
fclose(fp); /*关闭文件*/
printf("---You have success read data from file!!!---\n");
return h; /*返回头指针*/
}
/*追加记录到文件*/
void append()

{
FILE *fp; /*定义指向文件的指针*/
STUDENT *info; /*新记录指针*/
int s1,i;
char infile[10]; /*保存文件名*/
printf("\nplease new record\n");
info=(STUDENT *)malloc(sizeof(STUDENT)); /*申请空间*/
if(!info)
{
printf("\nout of memory"); /*没有申请到，内存溢出本函数结束*/
return ;
}
inputs("enter no:",info->no,11); /*调用inputs输入学号*/
inputs("enter name:",info->name,15); /*调用inputs输入姓名*/
printf("please input %d score \n",N); /*提示输入成绩*/
s1=0;
for(i=0;i<N;i++)
{
do{
printf("score%d:",i+1);
scanf("%d",&info->score[i]); /*输入成绩*/
if(info->score[i]>100||info->score[i]<0)printf("bad data,repeat input\n");
}while(info->score[i]>100||info->score[i]<0); /*成绩数据验证*/
s1=s1+info->score[i]; /*求总分*/
}
info->sum=s1; /*保存总分*/
info->average=(float)s1/N; /*求均分*/
info->order=0; /*名次初始值为0*/
info->next=NULL; /*将新记录后继指针赋值为空*/
printf("Enter infile name,for example c:\\f1\\te.txt:\n"); scanf("%s",infile); /*输入文件名*/
if((fp=fopen(infile,"ab"))==NULL) /*向二进制文件尾增加数据方式打开文件*/
{
printf("can not open file\n"); /*显示不能打开*/
exit(1); /*退出程序*/
}
printf("\n -----Appending record!-----\n");
if(1!=fwrite(info,sizeof(STUDENT),1,fp)) /*写文件操作*/
{
printf("-----file write error!-----\n");
return; /*返回*/
}
printf("-----append sucess!!----\n");
fclose(fp); /*关闭文件*/
}
/*文件拷贝*/
void ()
{
char outfile[10],infile[10];
FILE *sfp,*tfp; /*源和目标文件指针*/
STUDENT *p=NULL; /*移动指针*/
clrscr(); /*清屏*/
printf("Enter infile name,for example c:\\f1\\te.txt:\n");
scanf("%s",infile); /*输入源文件名*/
if((sfp=fopen(infile,"rb"))==NULL) /*二进制读方式打开源文件*/
{
printf("can not open input file\n");
exit(0);
}
printf("Enter outfile name,for example c:\\f1\\te.txt:\n"); /*提示输入目标文件名*/
scanf("%s",outfile); /*输入目标文件名*/
if((tfp=fopen(outfile,"wb"))==NULL) /*二进制写方式打开目标文件*/
{
printf("can not open output file \n");
exit(0);
}
while(!feof(sfp)) /*读文件直到文件尾*/
{
if(1!=fread(p,sizeof(STUDENT),1,sfp))
break; /*块读*/
fwrite(p,sizeof(STUDENT),1,tfp); /*块写*/
}
fclose(sfp); /*关闭源文件*/
fclose(tfp); /*关闭目标文件*/
printf("you have success file!!!\n"); /*显示成功拷贝*/
}
/*排序*/
STUDENT *sort(STUDENT *h)
{
int i=0; /*保存名次*/
STUDENT *p,*q,*t,*h1; /*定义临时指针*/
h1=h->next; /*将原表的头指针所指的下一个结点作头指针*/
h->next=NULL; /*第一个结点为新表的头结点*/
while(h1!=NULL) /*当原表不为空时，进行排序*/
{
t=h1; /*取原表的头结点*/
h1=h1->next; /*原表头结点指针后移*/
p=h; /*设定移动指针p，从头指针开始*/
q=h; /*设定移动指针q做为p的前驱，初值为头指针*/
while(t->sum<p->sum&&p!=NULL) /*作总分比较*/
{
q=p; /*待排序点值小，则新表指针后移*/
p=p->next;
}
if(p==q) /*p==q，说明待排序点值大，应排在首位*/
{
t->next=p; /*待排序点的后继为p*/
h=t; /*新头结点为待排序点*/
}
else /*待排序点应插入在中间某个位置q和p之间，如p为空则是尾部*/
{
t->next=p; /*t的后继是p*/
q->next=t; /*q的后继是t*/

}
}
p=h; /*已排好序的头指针赋给p，准备填写名次*/
while(p!=NULL) /*当p不为空时，进行下列操作*/
{
i++; /*结点序号*/
p->order=i; /*将名次赋值*/
p=p->next; /*指针后移*/
}
printf("sort sucess!!!\n"); /*排序成功*/
return h; /*返回头指针*/
}
/*计算总分和均值*/
void computer(STUDENT *h)
{
STUDENT *p; /*定义移动指针*/
int i=0; /*保存记录条数初值为0*/
long s=0; /*总分初值为0*/
float average=0; /*均分初值为0*/
p=h; /*从头指针开始*/
while(p!=NULL) /*当p不为空时处理*/
{
s+=p->sum; /*累加总分*/
i++; /*统计记录条数*/
p=p->next; /*指针后移*/
}
average=(float)s/i;/* 求均分，均分为浮点数，总分为整数，所以做类型转换*/
printf("\n--All students sum score is:%ld average is %5.2f\n",s,average);
}
/*索引*/
STUDENT *index(STUDENT *h)
{
STUDENT *p,*q,*t,*h1; /*定义临时指针*/
h1=h->next; /*将原表的头指针所指的下一个结点作头指针*/
h->next=NULL; /*第一个结点为新表的头结点*/
while(h1!=NULL) /*当原表不为空时，进行排序*/
{
t=h1; /*取原表的头结点*/
h1=h1->next; /*原表头结点指针后移*/
p=h; /*设定移动指针p，从头指针开始*/
q=h; /*设定移动指针q做为p的前驱，初值为头指针*/
while(strcmp(t->no,p->no)>0&&p!=NULL) /*作学号比较*/
{
q=p; /*待排序点值大，应往后插，所以新表指针后移*/
p=p->next;
}
if(p==q) /*p==q，说明待排序点值小，应排在首位*/
{
t->next=p; /*待排序点的后继为p*/
h=t; /*新头结点为待排序点*/
}
else /*待排序点应插入在中间某个位置q和p之间，如p为空则是尾部*/
{
t->next=p; /*t的后继是p*/
q->next=t; /*q的后继是t*/
}
}
printf("index sucess!!!\n"); /*索引排序成功*/
return h; /*返回头指针*/
}
/*分类合计*/
void total(STUDENT *h)
{
STUDENT *p,*q; /*定义临时指针变量*/
char sno[9],qno[9],*ptr; /*保存班级号的*/
float s1,ave; /*保存总分和均分*/
int i; /*保存班级人数*/
clrscr(); /*清屏*/
printf("\n\n *******************Total*****************\n");
printf("---class---------sum--------------average----\n");
p=h; /*从头指针开始*/
while(p!=NULL) /*当p不为空时做下面的处理*/
{
memcpy(sno,p->no,8); /*从学号中取出班级号*/
sno[8]='\0'; /*做字符串结束标记*/
q=p->next; /*将指针指向待比较的记录*/
s1=p->sum; /*当前班级的总分初值为该班级的第一条记录总分*/
ave=p->average; /*当前班级的均分初值为该班级的第一条记录均分*/
i=1; /*统计当前班级人数*/
while(q!=NULL) /*内循环开始*/
{
memcpy(qno,q->no,8); /*读取班级号*/
qno[8]='\0'; /*做字符串结束标记*/
if(strcmp(qno,sno)==0) /*比较班级号*/
{
s1+=q->sum; /*累加总分*/
ave+=q->average; /*累加均分*/
i++; /*累加班级人数*/
q=q->next; /*指针指向下一条记录*/
}
else
break; /*不是一个班级的结束本次内循环*/
}
printf("%s %10.2f %5.2f\n",sno,s1,ave/i);
if(q==NULL)
break; /*如果当前指针为空，外循环结束，程序结束*/
else
p=q; /*否则，将当前记录作为新的班级的第一条记录开始新的比较*/
}
printf("---------------------------------------------\n");
}

7. C语言程序设计——课程设计——通讯录管理系统

/*10.3.2源程序*/
/******头文件（.h）***********/
#include "stdio.h" /*I/O函数*/
#include "stdlib.h" /*标准库函数*/
#include "string.h"/*字符串函数*/
#include "ctype.h" /*字符操作函数*/
#define M 50 /*定义常数表示记录数*/
typedef struct /*定义数据结构*/
{
char name[20]; /*姓名*/
char units[30]; /*单位*/
char tele[10]; /*电话*/
}ADDRESS;
/******以下是函数原型*******/
int enter(ADDRESS t[]); /*输入记录*/
void list(ADDRESS t[],int n); /*显示记录*/
void search(ADDRESS t[],int n); /*按姓名查找显示记录*/
int delete(ADDRESS t[],int n); /*删除记录*/
int add(ADDRESS t[],int n); /*插入记录*/
void save(ADDRESS t[],int n); /*记录保存为文件*/
int load(ADDRESS t[]); /*从文件中读记录*/
void display(ADDRESS t[]); /*按序号查找显示记录*/
void sort(ADDRESS t[],int n); /*按姓名排序*/
void qseek(ADDRESS t[],int n); /*快速查找记录*/
void (); /*文件复制*/
void print(ADDRESS temp); /*显示单条记录*/
int find(ADDRESS t[],int n,char *s) ; /*查找函数*/
int menu_select(); /*主菜单函数*/
/******主函数开始*******/
main()
{
int i;
ADDRESS adr[M]; /*定义结构体数组*/
int length; /*保存记录长度*/
clrscr(); /*清屏*/
for(;;)/*无限循环*/
{
switch(menu_select()) /*调用主菜单函数，返回值整数作开关语句的条件*/
{
case 0:length=enter(adr);break;/*输入记录*/
case 1:list(adr,length);break; /*显示全部记录*/
case 2:search(adr,length);break; /*查找记录*/
case 3:length=delete(adr,length);break; /*删除记录*/
case 4:length=add(adr,length); break; /*插入记录*/
case 5:save(adr,length);break; /*保存文件*/
case 6:length=load(adr); break; /*读文件*/
case 7:display(adr);break; /*按序号显示记录*/
case 8:sort(adr,length);break; /*按姓名排序*/
case 9:qseek(adr,length);break; /*快速查找记录*/
case 10:();break; /*复制文件*/
case 11:exit(0); /*如返回值为11则程序结束*/
}
}
}
/*菜单函数，函数返回值为整数，代表所选的菜单项*/
menu_select()
{
char s[80];
int c;
gotoxy(1,25);/*将光标定为在第25行，第1列*/
printf("press any key enter menu......\n");/*提示压任意键继续*/
getch(); /*读入任意字符*/
clrscr(); /*清屏*/
gotoxy(1,1);
printf("********************MENU*********************\n\n");
printf(" 0. Enter record\n");
printf(" 1. List the file\n");
printf(" 2. Search record on name\n");
printf(" 3. Delete a record\n");
printf(" 4. add record \n");
printf(" 5. Save the file\n");
printf(" 6. Load the file\n");
printf(" 7. display record on order\n");
printf(" 8. sort to make new file\n");
printf(" 9. Quick seek record\n");
printf(" 10. the file to new file\n");
printf(" 11. Quit\n");
printf("***********************************************\n");
do{
printf("\n Enter you choice(0~11):"); /*提示输入选项*/
scanf("%s",s); /*输入选择项*/
c=atoi(s); /*将输入的字符串转化为整型数*/
}while(c<0||c>11); /*选择项不在0~11之间重输*/
return c; /*返回选择项，主程序根据该数调用相应的函数*/
}
/***输入记录，形参为结构体数组，函数值返回类型为整型表示记录长度*/
int enter(ADDRESS t[])
{
int i,n;
char *s;
clrscr(); /*清屏*/
printf("\nplease input num \n"); /*提示信息*/
scanf("%d",&n); /*输入记录数*/
printf("please input record \n"); /*提示输入记录*/
printf("name unit telephone\n");
printf("------------------------------------------------\n");
for(i=0;i<n;i++)
{
scanf("%s%s%s",t[i].name,t[i].units,t[i].tele); /*输入记录*/
printf("----------------------------------------------\n");
}
return n; /*返回记录条数*/
}
/*显示记录，参数为记录数组和记录条数*/
void list(ADDRESS t[],int n)
{
int i;
clrscr();
printf("\n\n*******************ADDRESS******************\n");
printf("name unit telephone\n");
printf("------------------------------------------------\n");
for(i=0;i<n;i++)
printf("%-20s%-30s%-10s\n",t[i].name,t[i].units,t[i].tele);
if((i+1)%10==0) /*判断输出是否达到10条记录*/
{
printf("Press any key continue...\n"); /*提示信息*/
getch(); /*压任意键继续*/
}
printf("************************end*******************\n");
}
/*查找记录*/
void search(ADDRESS t[],int n)
{
char s[20]; /*保存待查找姓名字符串*/
int i; /*保存查找到结点的序号*/
clrscr(); /*清屏*/
printf("please search name\n");
scanf("%s",s); /*输入待查找姓名*/
i=find(t,n,s); /*调用find函数，得到一个整数*/
if(i>n-1) /*如果整数i值大于n-1，说明没找到*/
printf("not found\n");
else
print(t[i]); /*找到，调用显示函数显示记录*/
}
/*显示指定的一条记录*/
void print(ADDRESS temp)
{
clrscr();
printf("\n\n********************************************\n");
printf("name unit telephone\n");
printf("------------------------------------------------\n");
printf("%-20s%-30s%-10s\n",temp.name,temp.units,temp.tele);
printf("**********************end***********************\n");
}
/*查找函数，参数为记录数组和记录条数以及姓名s */
int find(ADDRESS t[],int n,char *s)
{
int i;
for(i=0;i<n;i++)/*从第一条记录开始，直到最后一条*/
{
if(strcmp(s,t[i].name)==0) /*记录中的姓名和待比较的姓名是否相等*/
return i; /*相等，则返回该记录的下标号，程序提前结结束*/
}
return i; /*返回i值*/
}
/*删除函数，参数为记录数组和记录条数*/
int delete(ADDRESS t[],int n)
{
char s[20]; /*要删除记录的姓名*/
int ch=0;
int i,j;
printf("please deleted name\n"); /*提示信息*/
scanf("%s",s);/*输入姓名*/
i=find(t,n,s); /*调用find函数*/
if(i>n-1) /*如果i>n-1超过了数组的长度*/
printf("no found not deleted\n"); /*显示没找到要删除的记录*/
else
{
print(t[i]); /*调用输出函数显示该条记录信息*/
printf("Are you sure delete it(1/0)\n"); /*确认是否要删除*/
scanf("%d",&ch); /*输入一个整数0或1*/
if(ch==1) /*如果确认删除整数为1*/
{
for(j=i+1;j<n;j++) /*删除该记录，实际后续记录前移*/
{
strcpy(t[j-1].name,t[j].name); /*将后一条记录的姓名拷贝到前一条*/
strcpy(t[j-1].units,t[j].units); /*将后一条记录的单位拷贝到前一条*/
strcpy(t[j-1].tele,t[j].tele); /*将后一条记录的电话拷贝到前一条*/
}
n--; /*记录数减1*/
}
}
return n; /*返回记录数*/
}
/*插入记录函数，参数为结构体数组和记录数*/
int add(ADDRESS t[],int n)/*插入函数，参数为结构体数组和记录数*/
{
ADDRESS temp; /*新插入记录信息*/
int i,j;
char s[20]; /*确定插入在哪个记录之前*/
printf("please input record\n");
printf("************************************************\n");
printf("name unit telephone\n");
printf("--------------------------------------------------\n");
scanf("%s%s%s",temp.name,temp.units,temp.tele); /*输入插入信息*/
printf("------------------------------------------------\n");
printf("please input locate name \n");
scanf("%s",s); /*输入插入位置的姓名*/
i=find(t,n,s); /*调用find，确定插入位置*/
for(j=n-1;j>=i;j--) /*从最后一个结点开始向后移动一条*/
{
strcpy(t[j+1].name,t[j].name); /*当前记录的姓名拷贝到后一条*/
strcpy(t[j+1].units,t[j].units); /*当前记录的单位拷贝到后一条*/
strcpy(t[j+1].tele,t[j].tele); /*当前记录的电话拷贝到后一条*/
}
strcpy(t[i].name,temp.name); /*将新插入记录的姓名拷贝到第i个位置*/
strcpy(t[i].units,temp.units); /*将新插入记录的单位拷贝到第i个位置*/
strcpy(t[i].tele,temp.tele); /*将新插入记录的电话拷贝到第i个位置*/
n++; /*记录数加1*/
return n; /*返回记录数*/
}
/*保存函数，参数为结构体数组和记录数*/
void save(ADDRESS t[],int n)
{
int i;
FILE *fp; /*指向文件的指针*/
if((fp=fopen("record.txt","wb"))==NULL) /*打开文件，并判断打开是否正常*/
{
printf("can not open file\n");/*没打开*/
exit(1); /*退出*/
}
printf("\nSaving file\n"); /*输出提示信息*/
fprintf(fp,"%d",n); /*将记录数写入文件*/
fprintf(fp,"\r\n"); /*将换行符号写入文件*/
for(i=0;i<n;i++)
{
fprintf(fp,"%-20s%-30s%-10s",t[i].name,t[i].units,t[i].tele);/*格式写入记录*/
fprintf(fp,"\r\n"); /*将换行符号写入文件*/
}
fclose(fp);/*关闭文件*/
printf("****save success***\n"); /*显示保存成功*/
}
/*读入函数，参数为结构体数组*/
int load(ADDRESS t[])
{
int i,n;
FILE *fp; /*指向文件的指针*/
if((fp=fopen("record.txt","rb"))==NULL)/*打开文件*/
{
printf("can not open file\n"); /*不能打开*/
exit(1); /*退出*/
}
fscanf(fp,"%d",&n); /*读入记录数*/
for(i=0;i<n;i++)
fscanf(fp,"%20s%30s%10s",t[i].name,t[i].units,t[i].tele); /*按格式读入记录*/
fclose(fp); /*关闭文件*/
printf("You have success read data from file!!!\n"); /*显示保存成功*/
return n; /*返回记录数*/
}
/*按序号显示记录函数*/
void display(ADDRESS t[])
{
int id,n;
FILE *fp; /*指向文件的指针*/
if((fp=fopen("record.txt","rb"))==NULL) /*打开文件*/
{
printf("can not open file\n"); /*不能打开文件*/
exit(1); /*退出*/
}
printf("Enter order number...\n"); /*显示信息*/
scanf("%d",&id); /*输入序号*/
fscanf(fp,"%d",&n); /*从文件读入记录数*/
if(id>=0&&id<n) /*判断序号是否在记录范围内*/
{
fseek(fp,(id-1)*sizeof(ADDRESS),1); /*移动文件指针到该记录位置*/
print(t[id]); /*调用输出函数显示该记录*/
printf("\r\n");
}
else
printf("no %d number record!!!\n ",id); /*如果序号不合理显示信息*/
fclose(fp); /*关闭文件*/
}
/*排序函数，参数为结构体数组和记录数*/
void sort(ADDRESS t[],int n)
{
int i,j,flag;
ADDRESS temp; /*临时变量做交换数据用*/
for(i=0;i<n;i++)
{
flag=0; /*设标志判断是否发生过交换*/
for(j=0;j<n-1;j++)
if((strcmp(t[j].name,t[j+1].name))>0) /*比较大小*/
{
flag=1;
strcpy(temp.name,t[j].name); /*交换记录*/
strcpy(temp.units,t[j].units);
strcpy(temp.tele,t[j].tele);
strcpy(t[j].name,t[j+1].name);
strcpy(t[j].units,t[j+1].units);
strcpy(t[j].tele,t[j+1].tele);
strcpy(t[j+1].name,temp.name);
strcpy(t[j+1].units,temp.units);
strcpy(t[j+1].tele,temp.tele);
}
if(flag==0)break; /*如果标志为0，说明没有发生过交换循环结束*/
}
printf("sort sucess!!!\n"); /*显示排序成功*/
}
/*快速查找，参数为结构体数组和记录数*/
void qseek(ADDRESS t[],int n)
{
char s[20];
int l,r,m;
printf("\nPlease sort before qseek!\n"); /*提示确认在查找之前，记录是否已排序*/
printf("please enter name for qseek\n"); /*提示输入*/
scanf("%s",s); /*输入待查找的姓名*/
l=0;r=n-1; /*设置左边界与右边界的初值*/
while(l<=r) /*当左边界<=右边界时*/
{
m=(l+r)/2; /*计算中间位置*/
if(strcmp(t[m].name,s)==0) /*与中间结点姓名字段做比较判是否相等*/
{
print(t[m]); /*如果相等，则调用print函数显示记录信息*/
return ; /*返回*/
}
if(strcmp(t[m].name,s)<0) /*如果中间结点小*/
l=m+1; /*修改左边界*/
else
r=m-1; /*否则，中间结点大，修改右边界*/
}
if(l>r) /*如果左边界大于右边界时*/
printf("not found\n"); /*显示没找到*/
}
/*复制文件*/
void ()
{
char outfile[20]; /*目标文件名*/
int i,n;
ADDRESS temp[M]; /*定义临时变量*/
FILE *sfp,*tfp; /*定义指向文件的指针*/
clrscr();/*清屏*/
if((sfp=fopen("record.txt","rb"))==NULL) /*打开记录文件*/
{
printf("can not open file\n"); /*显示不能打开文件信息*/
exit(1); /*退出*/
}
printf("Enter outfile name,for example c:\\f1\\te.txt:\n"); /*提示信息*/
scanf("%s",outfile); /*输入目标文件名*/
if((tfp=fopen(outfile,"wb"))==NULL) /*打开目标文件*/
{
printf("can not open file\n"); /*显示不能打开文件信息*/
exit(1); /*退出*/
}
fscanf(sfp,"%d",&n); /*读出文件记录数*/
fprintf(tfp,"%d",n);/*写入目标文件数*/
fprintf(tfp,"\r\n"); /*写入换行符*/
for(i=0;i<n;i++)
{
fscanf(sfp,"%20s%30s%10s\n",temp[i].name,temp[i].units,
temp[i].tele); /*读入记录*/
fprintf(tfp,"%-20s%-30s%-10s\n",temp[i].name,
temp[i].units,temp[i].tele); /*写入记录*/
fprintf(tfp,"\r\n"); /*写入换行符*/
}
fclose(sfp); /*关闭源文件*/
fclose(tfp); /*关闭目标文件*/
printf("you have success file!!!\n"); /*显示复制成功*/
}

8. 求c语言编写电话薄实现添加删除修改就可以 最好有图形菜单,没有也可以

声明： 非原创

#include "stdio.h" /*标准输入输出函数库*/
#include "stdlib.h" /*标准函数库*/
#include "string.h" /*字符串函数库*/
#include "conio.h" /*屏幕操作函数库*/
#define HEADER1 " ---------------------------TELEPHONE BOOK---------------------------\n"
#define HEADER2 " | num | name | phonenumber | address | \n"
#define HEADER3 " |--------------|------------|-----------------|---------------------| \n"
#define FORMAT " | %-10s| %-10s| %-15s |%-20s | \n"
#define DATA p->num,p->name,p->phonenum,p->address
#define END " ---------------------------------------------------------------------\n"
#define N 100
int saveflag=0; /*是否需要存盘的标志变量*/
/*定义与电话簿有关的数据结构*/
typedef struct telebook /*标记为telebook*/
{
char num[4]; /*编号*/
char name[10]; /*姓名*/
char phonenum[15]; /*电话号码*/
char address[20]; /*地址*/
}TELEBOOK;

void menu() /*主菜单*/
{
system("cls"); /*调用DOS命令，清屏.与clrscr()功能相同*/
textcolor(13); /*在文本模式中选择新的字符颜色*/
gotoxy(10,5); /*在文本窗口中设置光标*/
cprintf(" The telephone-book Management System \n");
gotoxy(10,8);
cprintf(" *************************Menu********************************\n");
gotoxy(10,9);
cprintf(" * 1 input record 2 display record *\n");
gotoxy(10,10);
cprintf(" * 3 delete record 4 search record *\n");
gotoxy(10,11);
cprintf(" * 5 modify record 6 insert record *\n");
gotoxy(10,12);
cprintf(" * 7 sort record 8 save record *\n");
gotoxy(10,13);
cprintf(" * 0 quit system *\n");
gotoxy(10,14);
cprintf(" *************************************************************\n");
/*cprintf()送格式化输出至文本窗口屏幕中*/
}
/*格式化输出表头*/
void printheader()
{
printf(HEADER1);
printf(HEADER2);
printf(HEADER3);
}
/*格式化输出表中数据*/
void printdata(TELEBOOK pp)
{
TELEBOOK* p;
p=&pp;
printf(FORMAT,DATA);

}

/*显示数组temp[]中存储的电话簿记录，内容为telebook结构中定义的内容*/
void Disp(TELEBOOK temp[],int n)
{
int i;
if(n==0) /*表示没有电话簿记录*/
{
printf("\n=====>Not telephone record!\n");
getchar();
return;
}

printf("\n\n");
printheader(); /*输出表格头部*/
i=0;
while(i<n) /*逐条输出数组中存储的电话簿记录*/
{
printdata(temp[i]);
i++;
printf(HEADER3);
}
getchar();
}

void Wrong() /*输出按键错误信息*/
{
printf("\n\n\n\n\n***********Error:input has wrong! press any key to continue**********\n");
getchar();
}

void Nofind() /*输出未查找此记录的信息*/
{
printf("\n=====>Not find this telephone record!\n");
}

/*************************************************************
作用：用于定位数组中符合要求的记录，并返回保存该记录的数组元素下标值
参数：findmess[]保存要查找的具体内容; nameorphonenum[]保存按什么在数组中查找;
**************************************************************/
int Locate(TELEBOOK temp[],int n,char findmess[],char nameorphonenum[])
{
int i=0;
if(strcmp(nameorphonenum,"phonenum")==0) /*按电话号码查询*/
{
while(i<n)
{
if(strcmp(temp[i].phonenum,findmess)==0) /*若找到findmess值的电话号码*/
return i;
i++;
}
}
else if(strcmp(nameorphonenum,"name")==0) /*按姓名查询*/
{
while(i<n)
{
if(strcmp(temp[i].name,findmess)==0) /*若找到findmess值的姓名*/
return i;
i++;
}
}
return -1; /*若未找到，返回一个整数-1*/
}

/*输入字符串，并进行长度验证(长度<lens)*/
void stringinput(char *t,int lens,char *notice)
{
char n[255];
do{
printf(notice); /*显示提示信息*/
scanf("%s",n); /*输入字符串*/
if(strlen(n)>lens) printf("\n exceed the required length! \n");
/*进行长度校验，超过lens值重新输入*/
}while(strlen(n)>lens);
strcpy(t,n); /*将输入的字符串拷贝到字符串t中*/

}

/*增加电话簿记录*/
int Add(TELEBOOK temp[],int n)
{
char ch,num[10];
int i,flag=0;
system("cls");
Disp(temp,n); /*先打印出已有的电话簿信息*/

while(1) /*一次可输入多条记录，直至输入编号为0的记录才结束添加操作*/
{
while(1) /*输入记录编号，保证该编号没有被使用，若输入编号为0，则退出添加记录操作*/
{
stringinput(num,10,"input number(press '0'return menu):"); /*格式化输入编号并检验*/
flag=0;
if(strcmp(num,"0")==0) /*输入为0，则退出添加操作，返回主界面*/
{return n;}
i=0;
while(i<n) /*查询该编号是否已经存在，若存在则要求重新输入一个未被占用的编号*/
{
if(strcmp(temp[i].num,num)==0)
{
flag=1;
break;
}
i++;
}

if(flag==1) /*提示用户是否重新输入*/
{ getchar();
printf("==>The number %s is existing,try again?(y/n):",num);
scanf("%c",&ch);
if(ch=='y'||ch=='Y')
continue;
else
return n;
}
else
{break;}
}
strcpy(temp[n].num,num); /*将字符串num拷贝到temp[n].num中*/
stringinput(temp[n].name,15,"Name:");
stringinput(temp[n].phonenum,15,"Telephone:");
stringinput(temp[n].address,15,"Adress:");
saveflag=1;
n++;
}
return n;
}

/*按编号或姓名，查询电话簿记录*/
void Qur(TELEBOOK temp[],int n)
{
int select; /*1:按姓名查，2：按电话号码查，其他：返回主界面（菜单）*/
char searchinput[20]; /*保存用户输入的查询内容*/
int p=0;
if(n<=0) /*若数组为空*/
{
system("cls");
printf("\n=====>No telephone record!\n");
getchar();
return;
}
system("cls");
printf("\n =====>1 Search by name =====>2 Search by telephone number\n");
printf(" please choice[1,2]:");
scanf("%d",&select);
if(select==1) /*按姓名查询*/
{

stringinput(searchinput,10,"input the existing name:");
p=Locate(temp,n,searchinput,"name");
/*在数组temp中查找编号为searchinput值的元素，并返回该数组元素的下标值*/
if(p!=-1) /*若找到该记录*/
{
printheader();
printdata(temp[p]);
printf(END);
printf("press any key to return");
getchar();
}
else
Nofind();
getchar();
}
else if(select==2) /*按电话号码查询*/
{
stringinput(searchinput,15,"input the existing telephone number:");
p=Locate(temp,n,searchinput,"phonenum");
if(p!=-1)
{
printheader();
printdata(temp[p]);
printf(END);
printf("press any key to return");
getchar();
}
else
Nofind();
getchar();
}
else
Wrong();
getchar();

}

/*删除电话簿记录：先找到保存该记录的数组元素的下标值，然后在数组中删除该数组元素*/
int Del(TELEBOOK temp[],int n)
{
int sel;
char findmess[20];
int p=0,i=0;
if(n<=0)
{ system("cls");
printf("\n=====>No telephone record!\n");
getchar();
return n;
}
system("cls");
Disp(temp,n);
printf("\n =====>1 Delete by name =====>2 Delete by telephone number\n");
printf(" please choice[1,2]:");
scanf("%d",&sel);
if(sel==1)
{
stringinput(findmess,10,"input the existing name:");
p=Locate(temp,n,findmess,"name");
getchar();
if(p!=-1)
{
for(i=p+1;i<n;i++) /*删除此记录，后面记录向前移*/
{
strcpy(temp[i-1].num,temp[i].num);
strcpy(temp[i-1].name,temp[i].name);
strcpy(temp[i-1].phonenum,temp[i].phonenum);
strcpy(temp[i-1].address,temp[i].address);

}
printf("\n==>delete success!\n");
n--;
getchar();
saveflag=1;
}
else
Nofind();
getchar();
}
else if(sel==2) /*先按电话号码查询到该记录所在的数组元素的下标值*/
{
stringinput(findmess,15,"input the existing telephone number:");
p=Locate(temp,n,findmess,"phonenum");
getchar();
if(p!=-1)
{
for(i=p+1;i<n;i++) /*删除此记录，后面记录向前移*/
{
strcpy(temp[i-1].num,temp[i].num);
strcpy(temp[i-1].name,temp[i].name);
strcpy(temp[i-1].phonenum,temp[i].phonenum);
strcpy(temp[i-1].address,temp[i].address);
}
printf("\n=====>delete success!\n");
n--;
getchar();
saveflag=1;
}
else
Nofind();
getchar();
}
return n;
}

/*修改电话簿记录。先按输入的联系人姓名查询到该记录，
然后提示用户修改该记录编号之外的值，编号不能修改*/
void Modify(TELEBOOK temp[],int n)
{
char findmess[20];
int p=0;
if(n<=0)
{ system("cls");
printf("\n=====>No telephone number record!\n");
getchar();
return ;
}
system("cls");
printf("modify telephone book recorder");
Disp(temp,n);
stringinput(findmess,10,"input the existing name:"); /*输入并检验该姓名*/
p=Locate(temp,n,findmess,"name"); /*查询到该数组元素,并返回下标值*/
if(p!=-1) /*若p!=－1,表明已经找到该数组元素*/
{
printf("Number:%s,\n",temp[p].num);
printf("Name:%s,",temp[p].name);
stringinput(temp[p].name,15,"input new name:");

printf("Name:%s,",temp[p].phonenum);
stringinput(temp[p].phonenum,15,"input new telephone:");

printf("Name:%s,",temp[p].address);
stringinput(temp[p].address,30,"input new address:");

printf("\n=====>modify success!\n");
getchar();
Disp(temp,n);
getchar();
saveflag=1;
}
else
{Nofind();
getchar();
}
return ;
}

/*插入记录:按编号查询到要插入的数组元素的位置，然后在该记录编号之后插入一个新数组元素。*/
int Insert(TELEBOOK temp[],int n)
{
char ch,num[10],s[10]; /*s[]保存插入点位置之前的记录编号,num[]保存输入的新记录的编号*/
TELEBOOK newinfo;
int flag=0,i=0,kkk=0;
system("cls");
Disp(temp,n);
while(1)
{ stringinput(s,10,"please input insert location after the Number:");
flag=0;i=0;
while(i<n) /*查询该编号是否存在，flag=1表示该编号存在*/
{
if(strcmp(temp[i].num,s)==0) {kkk=i;flag=1;break;}
i++;
}
if(flag==1)
break; /*若编号存在，则进行插入之前的新记录输入操作*/
else
{ getchar();
printf("\n=====>The number %s is not existing,try again?(y/n):",s);
scanf("%c",&ch);
if(ch=='y'||ch=='Y')
{continue;}
else
{return n;}
}
}
/*以下新记录的输入操作与Add()相同*/

while(1)
{ stringinput(num,10,"input new Number:");
i=0;flag=0;
while(i<n) /*查询该编号是否存在，flag=1表示该编号存在*/
{
if(strcmp(temp[i].num,num)==0) {flag=1;break;}
i++;
}
if(flag==1)
{
getchar();
printf("\n=====>Sorry,The number %s is existing,try again?(y/n):",num);
scanf("%c",&ch);
if(ch=='y'||ch=='Y')
{continue;}
else
{return n;}
}
else
break;
}

strcpy(newinfo.num,num); /*将字符串num拷贝到newinfo.num中*/
stringinput(newinfo.name,15,"Name:");
stringinput(newinfo.phonenum,15,"Telephone:");
stringinput(newinfo.address,15,"Adress:");

saveflag=1; /*在main()有对该全局变量的判断，若为1,则进行存盘操作*/

for(i=n-1;i>kkk;i--) /*从最后一个组织元素开始往向移一个元素位置*/
{
strcpy(temp[i+1].num,temp[i].num);
strcpy(temp[i+1].name,temp[i].name);
strcpy(temp[i+1].phonenum,temp[i].phonenum);
strcpy(temp[i+1].address,temp[i].address);
}
strcpy(temp[kkk+1].num,newinfo.num); /*在kkk的元素位置后插入新记录*/
strcpy(temp[kkk+1].name,newinfo.name);
strcpy(temp[kkk+1].phonenum,newinfo.phonenum);
strcpy(temp[kkk+1].address,newinfo.address);
n++;
Disp(temp,n);
printf("\n\n");
getchar();
return n;
}

/*利用选择排序法实现数组的按记录编号或姓名的升序排序*/
void SelectSort(TELEBOOK temp[],int n)
{
int i=0,j=0,flag=0,indexmin,select;
char charflag[10];
TELEBOOK newinfo;
if(n<=0)
{ system("cls");
printf("\n=====>Not telephone record!\n");
getchar();
return ;
}
system("cls");
Disp(temp,n); /*显示排序前的所有记录*/
printf(" ==>1 SORT BY NUMBER ==>2 SORT BY NAME\n");
printf(" please choice[1,2]:");
scanf("%d",&select);
if(select==1) /*按记录编号排序*/
{
for(i=0;i<n-1;i++)
{
flag=32767;indexmin=0;
for(j=i;j<n;j++)
{ if(atoi(temp[j].num)<flag)
{ flag=atoi(temp[j].num);
indexmin=j;
}
}
strcpy(newinfo.num,temp[i].num); /*利用结构变量newinfo实现数组元素的交换*/
strcpy(newinfo.name,temp[i].name);
strcpy(newinfo.phonenum,temp[i].phonenum);
strcpy(newinfo.address,temp[i].address);

strcpy(temp[i].num,temp[indexmin].num);
strcpy(temp[i].name,temp[indexmin].name);
strcpy(temp[i].phonenum,temp[indexmin].phonenum);
strcpy(temp[i].address,temp[indexmin].address);

strcpy(temp[indexmin].num,newinfo.num);
strcpy(temp[indexmin].name,newinfo.name);
strcpy(temp[indexmin].phonenum,newinfo.phonenum);
strcpy(temp[indexmin].address,newinfo.address);
}
Disp(temp,n); /*显示排序后的所有记录*/
saveflag=1;
printf("\n =====>sort complete!\n");
getchar();
return;
}
else if(select==2)
{
for(i=0;i<n-1;i++)
{
charflag[0]=255;indexmin=0;
for(j=i;j<n;j++)
{ if(strcmp(temp[j].name,charflag)>0)
{ charflag[0]=temp[j].name;
indexmin=j;
}
}
strcpy(newinfo.num,temp[i].num); /*利用结构变量newinfo实现数组元素的交换*/
strcpy(newinfo.name,temp[i].name);
strcpy(newinfo.phonenum,temp[i].phonenum);
strcpy(newinfo.address,temp[i].address);

strcpy(temp[i].num,temp[indexmin].num);
strcpy(temp[i].name,temp[indexmin].name);
strcpy(temp[i].phonenum,temp[indexmin].phonenum);
strcpy(temp[i].address,temp[indexmin].address);

strcpy(temp[indexmin].num,newinfo.num);
strcpy(temp[indexmin].name,newinfo.name);
strcpy(temp[indexmin].phonenum,newinfo.phonenum);
strcpy(temp[indexmin].address,newinfo.address);
}
Disp(temp,n); /*显示排序后的所有记录*/
saveflag=1;
printf("\n =====>sort complete!\n");
getchar();
return;
}
else
{Wrong();
getchar();
getchar();
return;}

}

/*数据存盘,若用户没有专门进行此操作且对数据有修改，在退出系统时， 会提示用户存盘*/
void Save(TELEBOOK temp[],int n)
{
FILE* fp;
int i=0;
fp=fopen("c:\\telephon","w");/*以只写方式打开文本文件*/
if(fp==NULL) /*打开文件失败*/
{
printf("\n=====>open file error!\n");
getchar();
return ;
}
for(i=0;i<n;i++)
{
if(fwrite(&temp[i],sizeof(TELEBOOK),1,fp)==1)/*每次写一条记录或一个结构数组元素至文件*/
{
continue;
}
else
{
break;
}
}
if(i>0)
{
getchar();
printf("\n\n=====>save file complete,total saved's record number is:%d\n",i);
getchar();
saveflag=0;
}
else
{system("cls");
printf("the current link is empty,no telephone record is saved!\n");
getchar();
}
fclose(fp); /*关闭此文件*/
}

void main()
{
TELEBOOK tele[N]; /*定义TELEBOOK结构体*/
FILE *fp; /*文件指针*/
int select; /*保存选择结果变量*/
char ch; /*保存(y,Y,n,N)*/
int count=0; /*保存文件中的记录条数（或元素个数）*/

fp=fopen("C:\\telephon","a+");
/*以追加方式打开文本文件c:\telephon，可读可写，若此文件不存在，会创建此文件*/
if(fp==NULL)
{
printf("\n=====>can not open file!\n");
exit(0);
}

while(!feof(fp))
{
if(fread(&tele[count],sizeof(TELEBOOK),1,fp)==1) /*一次从文件中读取一条电话簿记录*/
count++;
}
fclose(fp); /*关闭文件*/
printf("\n==>open file sucess,the total records number is : %d.\n",count);
getchar();
menu();
while(1)
{
system("cls");
menu();
printf("\n Please Enter your choice(0~8):"); /*显示提示信息*/
scanf("%d",&select);

if(select==0)
{
if(saveflag==1) /*若对数组的数据有修改且未进行存盘操作，则此标志为1*/
{ getchar();
printf("\n==>Whether save the modified record to file?(y/n):");
scanf("%c",&ch);
if(ch=='y'||ch=='Y')
Save(tele,count);
}
printf("\n===>thank you for useness!");
getchar();
break;
}

switch(select)
{
case 1:count=Add(tele,count);break; /*增加电话簿记录*/
case 2:system("cls");Disp(tele,count);break; /*显示电话簿记录*/
case 3:count=Del(tele,count);break; /*删除电话簿记录*/
case 4:Qur(tele,count);break; /*查询电话簿记录*/
case 5:Modify(tele,count);break; /*修改电话簿记录*/
case 6:count=Insert(tele,count);break; /*插入电话簿记录*/
case 7:SelectSort(tele,count);break; /*排序电话簿记录*/
case 8:Save(tele,count);break; /*保存电话簿记录*/
default: Wrong();getchar();break; /*按键有误，必须为数值0-9*/
}
}
}

9. 数据结构 c语言编程

你的 crt_linklist函数有问题，应为在你的主函数中，你在调用 crt_linklist函数时，实际上进行的的是值传递！你后来的初始化函数init_linklist以及创建链表函数crt_linklist对p都没有什么影响！这两个函数所做的工作就只是对自己的形参处理了而已，当函数调用结束时，一切又消失了，实参p还是原来的样子。你可以考虑在主函数中这样修改就可以了：

int main()
{
lnode l;
elemtype i=30;
crt_linklist(&l,i);
output_linklist(&l);
return 0;
}

这种问题自己必须想明白，我们当初学习时也经常碰到这种问题，但只要你好好想想，这些问题就都能想明白的，你可以不断实践加深自己的理解！