线性表的基本运算

班级： 姓名：实训成绩：□□批改教师签名：

一、实训学时：2学时

二、实训目的：

理解线性表的概念，掌握线性表的存储方法以及建立在该存储方法上的各种线性表算法，并用C/C++调试实现。

三、实训原理：

线性表是一种数据结构，它有多种存储方法，不同存储方法对应的线性表算法都有着相同的功能和不同的实现。学生实验时，线性表的存储结构可以通过数组和链表来实现，而线性表的各种算法则就是为实现相同功能而进行的数组或链表操作。

四、实训设备：

一台可以建立C/C++语言程序调试环境的个人计算机。

五、主要实训内容及编程：

１、线性表的各种存储结构的实训（用C/C++语言描述，用实训过程中的实训内容填写，实训过程中检查）。

相关线性表实训的前提必须使学生掌握并理解线性表的概念，并搞清楚什么是数据结构。数据结构不仅仅与数据的存储结构有关，同时与相关存储结构的算法有关。数据结构=数据的结构+算法。所以，线性表的存储结构十分重要。当然，线性表的存储结构有许多种，比如数组、链表等。下面给出一例：

#define ListSize 20

//List structure

typedef int DataType; //DataType的类型可根据实际情况而定，这里假设为int

typedef struct{

DataType data[ListSize]; //向量data用于存放表结点

int length; //当前的表长度

}seqList;

2、基于某种线性表存储结构给出线形表操作的各种算法实训（用C/C++语言描述，用实训过程中的实训内容填写，实训过程中检查检查）。

#include

#include

#define ListSize 20

//List structure

typedef int DataType; //DataType的类型可根据实际情况而定，这里假设为int

typedef struct{

DataType data[ListSize]; //向量data用于存放表结点

int length; //当前的表长度

}seqList;

//menu

void menu(){

printf("\nCreate and Init a list: -> 1\n");

printf("Get the length: -> 2\n");

printf("Get the ith node: -> 3\n");

printf("Find the node =x: -> 4\n");

printf("Insert the node x: -> 5\n");

printf("Delete the node x: -> 6\n");

printf("Your choice is: "); }

//Create and init a list

seqList* Init_seqlist(){

// int num;

int i=0;

seqList *list;

list=(seqList *)malloc(sizeof(seqList));

//从键盘输入

/*

printf("please input the seq number:");

scanf("%d",&num);

while(num!=-1){list->data[i++]=num;

scanf("%d",&num);}

list->data[i]=-1;

list->length=--i;

*/

//默认值

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

list->data[i]=i*10;

list->data[i]=-1;

list->length=i;

return list; }

//output the list

void output_seqlist(seqList *list)

{

int i=0;

printf("The sequence is: ");

while(list->data[i]!=-1)

printf("%d ",list->data[i++]);

printf("\n");

}

//get length of the list

int length_seqlist(seqList *list)

{

return list->length;

}

//get the node of i in the list

void getnode_seqlist(seqList *list)

{

int i;

printf("i=");

scanf("%d",&i);

printf("list->data[%d] = %d \n", i, list->data[i]);

}

//find node in the list

void findnode_seqlist(seqList *list)

{

int found=0, i=0, x;

printf("x=");

scanf("%d",&x);

while(list->data[i]!=-1)

{

if(list->data[i++]==x){found=1;break;}

}

if(!found)printf("Not found!\n");

else printf("Found! i= %d \n",--i);

}

//insert a node into the list

void insert_seqlist(seqList *list)

{

int i,x;

printf("insert x= ");

scanf("%d",&x);

list->data[list->length+1]=-1;

for(i=list->length-1;i>=0;i--)

{

if(xdata[i]){list->data[i+1]=list->data[i];}

else

{ list->data[i+1]=x;break;}

}

list->length++;}

//delete a node of the list

void delete_seqlist(seqList *list)

{

int x,i=0;

printf("delete x=");

scanf("%d",&x);

while(list->data[i]!=x)

{

if(i==list->length)

{ printf("no such node = %d in the sequence!\n",x);

return;

}

i++;

}

if(list->data[i]==x)

{

for(i;ilength;i++)

{list->data[i]=list->data[i+1];}

list->length--;

}

}

void main()

{

int n;

seqList *list;

menu();

while(1)

{

printf("Your choice is: ");

scanf("%d",&n);

switch(n)

{

case 1:{list=Init_seqlist();output_seqlist(list);break;}

case 2:{printf("the length of list is %d\n",length_seqlist(list));break;}

case 3:{getnode_seqlist(list);break;}

case 4:{findnode_seqlist(list);break;}

case 5:{insert_seqlist(list);output_seqlist(list);break;}

case 6:{delete_seqlist(list);output_seqlist(list);break;}

}

}

}

3、挑选一个你实训中使用过的较为复杂的算法，研究它的时间复杂性。

void insertLastList(struct List *L, elemType x)

{

if(L->size == L ->maxSize){ /* 重新分配更大的存储空间 */

againMalloc(L);

}

L->list[L->size] = x; /* 把x插入到表尾 */

L->size++; /* 线性表的长度增加１ */

return;

}int main()

{

int a[10] = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20};

int i;

struct List L;

initList(&L, 5);

for(i = 0; i < 10; i++){

insertLastList(&L, a[i]);

}

insertPosList(&L, 11, 48); insertPosList(&L, 1, 64);

printf("%d ", getElem(&L, 1));

traverseList(&L);

printf("%d ", findList(&L, 10));

updatePosList(&L, 3, 20);

printf("%d ", getElem(&L, 3));

traverseList(&L);

deleteFirstList(&L); deleteFirstList(&L);

deleteLastList(&L); deleteLastList(&L);

deletePosList(&L, 5); ;deletePosList(&L, 7);

printf("%d ", sizeList(&L));

printf("%d ", emptyList(&L));

traverseList(&L);

clearList(&L);

return 0;

}

答：插入表中第i个位置结点的移动次数为n-i。pi表示插入表中第i个位置上结点的概率。不失一般性，假设在表中任何合法位置(1≤i≤n)上的插入结点的机会是均等的，则p 1 =p 2 =…=p n =1/n因此，在等概率插入的情况下，顺序表上做插入运算，平均要移动表中约一半的结点，平均时间复杂度也是0(n)。

数据排序与查找

班级： 姓名：实训成绩：□□批改教师签名：

一、实训学时：2学时

二、实训目的：

学习和理解数据排序和查找的不同实现方法，了解实现它们的技巧和方法。

三、实训原理：

任选一种排序和查找算法用C/C++实现，通过实验说明它们的复杂度以及适用范围。

四、实训设备：

一台可以建立C/C++语言程序调试环境的个人计算机。

五、主要实训内容及编程：

１、数据排序算法实训（至少完成2个算法的实训，用C/C++语言描述，用实训过程中的实训内容填写，实训过程中检查）。

冒泡排序

#include "stdio.h"

void pcbub(p,n)

int n;

char p[];

{ int m,k,j,i;

char d;

k=0; m=n-1;

while (k

{ j=m-1; m=0;

for (i=k; i<=j; i++)

if (p[i]>p[i+1])

{ d=p[i]; p[i]=p[i+1]; p[i+1]=d; m=i;}

j=k+1; k=0;

for (i=m; i>=j; i--)

if (p[i-1]>p[i])

{ d=p[i]; p[i]=p[i-1]; p[i-1]=d; k=i;}

}

return;

}

main()

{ char *s;

static char p[]={'a','s','t','b','x','e','f','h','i',

'g','p', 'q','a','i','f','j','c','b','a','z','y','x'};

s=p+2;

printf("\n");

printf("%s\n",p);

printf("\n");

pcbub(s,17);

printf("%s\n",p);

printf("\n");

}

堆排序

#include "stdio.h"

void pchap(p,n)

int n;

char p[];

{ int i,mm;

char t;

void csift();

mm=n/2;

for (i=mm-1; i>=0; i--)

csift(p,i,n-1);

for (i=n-1; i>=1; i--)

{ t=p[0]; p[0]=p[i]; p[i]=t;

csift(p,0,i-1);

}

return;

}

static void csift(p,i,n)

int i,n;

char p[];

{ int j;

char t;

t=p[i]; j=2*(i+1)-1;

while (j<=n)

{ if ((j

if (t

{ p[i]=p[j]; i=j; j=2*(i+1)-1;}

else j=n+1;

}

p[i]=t;

return;

}

main()

{ char *s;

static char p[]={'a','s','t','b','x','e','f','h','i',

'g','p', 'q','a','i','f','j','c','b','a','z','y','x'};

s=p+2;

printf("\n");

printf("%s\n",p);

printf("\n");

pchap(s,17);

printf("%s\n",p);

printf("\n");

}

堆排序

#define HEAPSORT struct student

#define KEY sex

HEAPSORT

{ int num;

char name[8];

char sex;

int age;

double score;

};

#include "stdio.h"

static void pcsift(HEAPSORT *p[],int k,int i,int l)

{ int m,n;

char t;

HEAPSORT *w;

t=(*p[i+k]).KEY; w=p[i+k]; n=2*(i+1)-1; m=i;

while (n<=l-1)

{ if ((n

n=n+1;

if (t<(*p[n+k]).KEY)

{ p[m+k]=p[n+k];

m=n; n=2*(m+1)-1;

}

else n=l;

}

p[m+k]=w;

return;

}

void pckey( HEAPSORT *p[],int n,int k,int m)

{ int i,l;

HEAPSORT *w;

void pcsift();

if (k<0) k=0;

if (m>n-1) m=n-1;

l=m-k+1;

for (i=l/2-1; i>=0; i--)

// pcsift(p,k,i,l);

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

{ w=p[k]; p[k]=p[i+k]; p[i+k]=w;

// pcsift(p,k,0,i);

}

return;

}

main()

{ int i;

static HEAPSORT stu[10]={{101,"Zhang",'M',19,95.6},

{102,"Wang",'F',18,92.4},{103,"Zhao",'M',19,85.7},

{104,"Li",'M',20,96.3},{105,"Gou",'M',19,90.2},

{106,"Lin",'M',18,91.5},{107,"Ma",'F',17,98.7},

{108,"Zhen",'M',21,90.1},{109,"Xu",'M',19,89.8},

{110,"Mao",'F',18,94.9}};

HEAPSORT *p[10];

for (i=0; i<=9; i++) p[i]=&stu[i];

printf("\n");

printf("No. Name Sex Age Score\n");

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

printf("%-8d%-9s%-8c%-8d%-5.2f\n",

(*p[i]).num,(*p[i]).name,(*p[i]).sex,

(*p[i]).age,(*p[i]).score);

printf("\n");

pckey(p,10,1,8);

printf("No. Name Sex Age Score\n");

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

printf("%-8d%-9s%-8c%-8d%-5.2f\n",

(*p[i]).num,(*p[i]).name,(*p[i]).sex,

(*p[i]).age,(*p[i]).score);

printf("\n");

}

2、数据查找算法实训（至少完成2个算法的实训，用C/C++语言描述，用实训过程中的实训内容填写，实训过程中检查）。

#include

#define max 5

int seq_search(int s[],int key)

{

int i=max;

s[0]=key;

while(s[i]!=key)

i--;

if(i>0)

{

printf("查找成功");

return i;

}

else

{

printf("查找失败");

return 0;

}

}

void main()

{

int s[max];

int j,k;

printf("请输入数据：");

for(j=1;j

scanf("%d",&s[j]);

printf("请输入要查找的数:");

scanf("%d",&k);

seq_search(s,k);

}

3、挑选两个你实训中使用过的排序算法，比较它们的优缺点。

冒泡排序优点：1，比较简单；

2，空间复杂度较低；

3，比较稳定

冒泡排序缺点：1，时间复杂度太高；

2，效率不好；

堆排序优点：对于较大规模的线性表来说是比较有效的；

缺点：对于较小规模的线性表并不适合；

4、挑选两个你实训中使用过的查找算法，比较它们的优缺点。

答：顺序查找，对分查找。顺序查找的效率很低，但有时只能

用顺序查找。例如：如果线性表为无序表，或采用链式存储结构。

对分查找只适用于顺序存储的有序表。

5、挑选一个你实训中使用过的较为复杂的算法，研究它的时间复杂性。

冒泡排序时间复杂性的分析：

若记录序列的初始状态为"正序"，则冒泡排序过程只需进行一趟排序，在排序过程中只需进行n-1次比较，且不移动记录；反之，考虑最坏情况，若记录序列的初始状态为"逆序"，则有第一次进行n-1次比较，n-1次移动，第二次进行n-2次比较，n-2次移动 第三次进行n-3次比较，n-3次移动

第n-1次进行1次比较，1次移动共需进行1+2+3+ +n-1=n(n-1)/2次比较和记录移动。因此冒泡排序总的时间复杂度为O(n*n ）

数据库技术的应用

班级： 姓名： 实训成绩：□□批改教师签名：

一、实训学时：2学时

二、实训目的：

理解并掌握数据库检索系统的建立方法。

三、实训原理：

通过C++或VB语言中的数据库的建立和编程手段，使学生在数据库系统构建、检索等数据库系统操作方面得到锻炼和提高，从而达到对数据库系统的完整理解。

四、实训设备：

一台可以建立C/C++语言程序调试环境的个人计算机。

五、主要实训内容及编程：

１、关系数据库建立实训（至少建立2个关系数据库，并能对所建立的数据库结构进行必要地修改。用实训过程中的实训内容填写，实训过程中检查）。

1，COURSE

2,ENROLLS

3,STUDENTS

2、关系数据库数据记录的添加、检索、修改、删除等操作实训（在1的基础上利用SQL语言进行实训。实训内容记录包括：数据库结构、数据库中数据、数据库操作命令以及结果。用实训过程中的实训内容填写，实训过程中检查）。

查找

3、数据库有那些种类？它们对应的操作是否有所不同？

答：1、层次型2、网状型3、关系型

是。层次型最明显的特点是层次清楚，构造简单，易于实现。它很方便的表示出一对一和一对多的联系。网状型能方便的描述较为复杂的数据关系，可以直接表示实体之间多对多的联系。关系型数据结构比较简单。具有很高的数据独立性。可以直接处理多对多的联系。

应用软件设计

班级：姓名： 实训成绩：□□批改教师签名：

一、实训学时：2学时

二、实训目的：

学习和理解应用软件的设计方法并设计一个简单的应用软件系统。

三、实训原理：

通过模块设计用C/C++实现一个简单的应用软件系统。

四、实训设备：

一台可以建立C/C++语言程序调试环境的个人计算机。

五、主要实训内容及编程：

1、应用软件模块组织实训（根据过去的实训内容或根据教师提供代码参考，设计并实现有一定意义的软件模块并用菜单技术将他们合理地组织在一起。用C/C++语言描述，用实训过程中的实训内容填写，实训过程中检查）。

/////////////////////////////////////////////////////////////////////

///////////// List.h: 类的所有成员都在头文件里声明 //////////////////

/////////////////////////////////////////////////////////////////////

#include // cin 及 cout

#include // 用到申请内存函数 malloc() 和释放内存函数 free()

#include // 字符串处理

#include // 文件操作（读文件）

#include // system("cls")

struct address /*家庭地址*/

{

char city[10]; /*城市*/

char town[10]; /*县城*/

char village[10]; /*乡镇*/

};

struct telephone /*联系方式*/

{

char SJ[50]; /*手机*/

char JD[30]; /*家庭电话*/

char XD[30]; /*学校电话*/

};

struct person /*个人信息*/

{

char name[20]; /*名字*/

char sex[10] ; /*性别*/

char MZ[16]; /*民族*/

char GJ[17]; /*国籍*/

char XL[19]; /*学历*/

};

struct score //成绩

{

char num[20]; //学号

char english[20];

char chinese[20];

char math[20];

char physics[20];

};

typedef struct linknode //定义节点的类型

{

char address[100]; //地址

char birthday[100]; //出生日期

struct score sc; //成绩

struct person pe; //个人信息

struct telephone te; //联系方式

bool flag;

struct linknode* next;

}nodetype;

class List

{

nodetype* head;

public:

List();

List::~List();

linknode* creatlist(int); //创建链表

int listlen(); //返回链表长度

nodetype* findnode(int); //通过查找序号返回节点的指针

nodetype* find(char c[]); //通过查找姓名返回节点的指针

int find2(char c[]); //通过查找姓名返回节点的序号

nodetype* insnode(int); //插入节点

void delnode(int); //删除节点

nodetype* load(); //初始化：从外部读入数据

void readstr(FILE *f,char *string); //读行函数

bool check(char *a, char *b); //对比两个字符串是否相等

void help(); //显示帮助菜单

void editperson(nodetype*); //编辑个人说明

void editscore(nodetype*); //编辑学科成绩

void edittelephone(nodetype*); //编辑联系方式

void dispname(); //显示所有学生姓名

void dispnode(nodetype* p); //显示一个学生的所有信息

void dispperson(nodetype*); //显示一个学生的个人说明

void dispscore(nodetype*); //显示一个学生的学科成绩

void disptelephone(nodetype*); //显示一个学生的联系方式

};

2、应用软件中数据结构构建以及模块组织实训（根据提供代码参考，研究并设计实现有一定意义的简单的软件系统。用C/C++语言描述，用实训过程中的实训内容填写，实训过程中检查）。

/////////////////////////////////////////////////////////////////////

///////////// List.h: 类的所有成员都在头文件里声明 //////////////////

/////////////////////////////////////////////////////////////////////

#include "operater.h"

void Operater::display()

{

cout<

cout<<"**************************** 学生管理系统 **************************"<

cout<<"1: 添加一个学生信息"<

cout<<"2: 删除一个学生信息"<

cout<<"3: 显示所有学生的姓名"<

cout<<"4: 根据姓名显示单个学生所有信息"<

cout<<"5: 根据姓名对单个学生进行编辑"<

cout<<"6: 帮助菜单"<

cout<<"7: 保存数据"<

cout<<"0: 退出系统"<

cout<<"********************************************************************"<

}

void Operater::Loop()

{

List L1; //List 对象

char ch[20];

nodetype *p, *head;

int i; //存放节点序号

p=L1.load(); //初始化：从外部读入数据创建链表

head=p;

display();

while(1)

{

cout<

cout<<"请输入选择（帮助选项--> 6 ）: "<

cin>>ch;

system("cls");

if(L1.check(ch, "1"))

{

p=L1.insnode(0);

head=p;

system("cls");

cout<

cout<<"************** 添加一个学生信息 ******************"<

cout<<"下面输入个人信息: "<

L1.editperson(p);

cout<<"下面输入学科成绩: "<

L1.editscore(p);

cout<<"下面输入联系方式: "<

L1.edittelephone(p);

}

if(L1.check(ch, "2"))

{

system("cls");

cout<

cout<<"************** 删除一个学生信息 ******************"<

L1.dispname();

cout<<"请输入学生姓名: "<

cin>>ch;

i=L1.find2(ch);

L1.delnode(i);

}

if(L1.check(ch, "3"))

{

system("cls");

cout<

cout<<"************** 显示所有学生姓名 ******************"<

L1.dispname();

}

if(L1.check(ch, "4"))

{

system("cls");

cout<

cout<<"************** 根据姓名显示单个学生所有信息 ******************"<

L1.dispname();

cout<<"请输入学生姓名: "<

cin>>ch;

p=L1.find(ch);

L1.dispnode(p);

}

if(L1.check(ch, "6"))

{

display();

}

if(L1.check(ch, "7")) //保存数据

{

FILE *fp;

if((fp=fopen("student.txt", "w"))==NULL)

{

cout<<"打开文件失败"<

return;

}

int i;

char t[255];

//将 L1.listlen() 赋予字符串中的数字

sprintf(t, "The Length Of Link: %d\n", L1.listlen());

fputs(t, fp);

strcpy(t, "\n");

fputs(t, fp);

p=L1.findnode(1); //将链表头指针赋予 p

for(i=0; i

{

fputs(p->address, fp); //输出地址

fputs(p->birthday, fp); //输出生日

fputs(p->sc.num, fp); //输出学号

fputs(p->sc.chinese, fp); //输出语文成绩

fputs(p->sc.english, fp); //输出英语成绩

fputs(p->sc.math, fp); //输出数学成绩

fputs(p->sc.physics, fp); //输出物理成绩

fputs(p->pe.name, fp); //输出姓名

fputs(p->pe.sex, fp); //输出性别

fputs(p->pe.GJ, fp); //输出国籍

fputs(p->pe.MZ, fp); //输出民族

fputs(p->pe.XL, fp); //输出学历

fputs(p->te.SJ, fp); //输出手机

fputs(p->te.JD, fp); //输出家庭电话

fputs(p->te.XD, fp); //输出学校电话

fputs(t, fp);

p=p->next;

}

p=head;

fclose(fp);

}

if(L1.check(ch, "5"))

{

char c[20];

system("cls");

cout<

cout<<"************** 根据姓名对单个学生进行编辑 ******************"<

L1.dispname();

cout<<"请输入学生姓名: "<

cin>>c;

p=L1.find(c);

system("cls");

cout<

cout<<"*********************************************************"<

cout<<"1: 编辑个人信息"<

cout<<"2: 编辑学科成绩"<

cout<<"3: 编辑联系方式"<

cout<<"4: 显示个人信息"<

cout<<"5: 显示学科成绩"<

cout<<"6: 显示联系方式"<

cout<<"7: 显示该学生所有信息"<

cout<<"8: 帮助菜单"<

cout<<"9: 返回上一级菜单"<

cout<<"*********************************************************"<

while(1)

{

cout<

cout<<"请输入选择（帮助选项--> 8 ）: "<

cin>>c;

system("cls");

if(L1.check(c, "1"))

{

system("cls");

cout<

cout<<"************** 编辑个人信息 ******************"<

L1.editperson(p);

}

else if(L1.check(c, "2"))

{

system("cls");

cout<

cout<<"************** 编辑学科成绩 ******************"<

L1.editscore(p);

}

else if(L1.check(c, "3"))

{

system("cls");

cout<

cout<<"************** 编辑联系方式 ******************"<

L1.edittelephone(p);

}

else if(L1.check(c, "4"))

{

system("cls");

cout<

cout<<"************** 显示个人信息 ******************"<

L1.dispperson(p);

}

else if(L1.check(c, "5"))

{

system("cls");

cout<

cout<<"************** 显示学科成绩 ******************"<

L1.dispscore(p);

}

else if(L1.check(c, "6"))

{

system("cls");

cout<

cout<<"************** 显示联系方式 ******************"<

L1.disptelephone(p);

}

else if(L1.check(c, "7"))

{

system("cls");

L1.dispnode(p);

}

else if(L1.check(c, "8"))

{

system("cls");

L1.help();

}

else if(L1.check(c, "9"))

{

display();

break; //用 break 跳出本循环，不要用 return ，return 是退出程序

}

}

}

else if(L1.check(ch, "0"))

return;

}

return;

}

/////////////////////////////////////////////////////////////////////////////////////

//////////////////////// List.cpp : The body of the class List //////////////////////

/////////////////////////////////////////////////////////////////////////////////////

#include "list.h"

List::List()

{

head = NULL;

}

bool List::check(char *a, char *b) //对比两个字符串是否相等

{

int i;

int j=strlen(b);

for(i=0; i

{

if(*a==*b)

{

a++;

b++;

}

else

return 0;

}

return 1;

}

nodetype* List::creatlist (int n) //创建链表

{

nodetype *h=NULL, *s, *t;

int i=1;

for(int j=0; j

{

if(i==1) //创建第一个节点

{

h=(nodetype*)malloc(sizeof(nodetype));

h->next=NULL;

t=h;

}

else //创建其余节点

{

s=(nodetype*)malloc(sizeof(nodetype));

s->next=NULL;

t->next=s;

t=s; //t 始终指向生成的单链表的最后一个节点

}

i++;

}

head=h;

return h;

}

/*

nodetype* List::creatlist (int n) //创建链表

{

nodetype *h=NULL;

int i=1;

for(int j=0; j

{

h=insnode(0);

}

head=h;

return h;

}

*/

void List::readstr(FILE *f,char *string)

{

do

{

//①: 先读入一行文本

fgets(string, 255, f); //fgets(): 从文件 f 读入长度为 255-1 的字符串

// 并存入到 string 中

} while ((string[0] == '/') || (string[0] == '\n'));

return;

}

nodetype* List::load()

{

FILE *fp;

nodetype *p;

char c[255];

int num;

if((fp=fopen("student.txt", "r"))==NULL)

{

cout<<"打开文件失败"<

return 0;

}

readstr(fp, c);

sscanf(c, "The Length Of Link: %d", &num); //获取链表长度

p=creatlist(num); //创建链表

for(int i=0; i

{

readstr(fp, c);

strcpy(p->address, c);

readstr(fp, c);

strcpy(p->birthday, c);

readstr(fp, c);

strcpy(p->sc.num, c);

readstr(fp, c);

strcpy(p->sc.chinese, c);

readstr(fp, c);

strcpy(p->sc.english, c);

readstr(fp, c);

strcpy(p->sc.math, c);

readstr(fp, c);

strcpy(p->sc.physics, c);

readstr(fp, c);

strcpy(p->pe.name, c);

readstr(fp, c);

strcpy(p->pe.sex, c);

readstr(fp, c);

strcpy(p->pe.GJ, c);

readstr(fp, c);

strcpy(p->pe.MZ, c);

readstr(fp, c);

strcpy(p->pe.XL, c);

readstr(fp, c);

strcpy(p->te.SJ, c);

readstr(fp, c);

strcpy(p->te.JD, c);

readstr(fp, c);

strcpy(p->te.XD, c);

p=p->next;

}

fclose(fp);

return p;

}

void List::dispnode(nodetype* p) //显示一个学生的所有信息

{

if(p!=NULL)

{

dispperson(p);

dispscore(p);

disptelephone(p);

}

}

void List::dispname() //显示所有学生姓名

{

nodetype* p=head;

cout<<"现有的学生: "<

if(p==NULL)

cout<<"没有任何学生数据"<

while(p!=NULL)

{

cout<<"姓名: "<pe.name;

p=p->next;

}

}

int List::listlen() //返回链表长度

{

int i=0;

nodetype* p=head;

while(p!=NULL)

{

p=p->next;

i++;

}

return i;

}

nodetype* List::findnode (int i) //通过查找序号返回节点的指针

{

nodetype* p=head;

int j=1;

if( i>listlen()||i<=0 ) // i 上溢或下溢

return NULL;

else

{

while( p!=NULL && j查找第 i 个节点并由 p 指向该节点

{

j++;

p=p->next;

}

return p;

}

}

nodetype* List::find(char c[]) //通过查找姓名返回节点的指针

{

nodetype* p=head;

int j=1;

strcat(c, "\n"); //从外部读入的字符串末尾都带了一个换行符

while( p!=NULL && !(check(c, p->pe.name))) //查找第 i 个节点并由 p 指向该节点

{

j++;

p=p->next;

}

return p;

}

int List::find2(char c[]) //通过查找姓名返回节点的序号

{

nodetype* p=head;

int j=1;

strcat(c, "\n"); //从外部读入的字符串末尾都带了一个换行符

while( p!=NULL && !(check(c, p->pe.name))) //查找第 i 个节点并由 p 指向该节点

{

j++;

p=p->next;

}

return j;

}

nodetype* List::insnode(int i)

{

nodetype *h=head, *p, *s;

s=(nodetype*)malloc(sizeof(nodetype)); //创建节点 s

s->next=NULL;

if(i==0) //i=0 时 s 作为该单链表的第一个节点

{

s->next = h;

h=s; //重新定义头节点

}

else

{

p=findnode(i); //查找第 i 个节点，并由 p 指向该节点

if(p!=NULL)

{

s->next=p->next;

p->next=s;

}

else cout<<"输入的 i 值不正确"<

}

head=h;

return s;

}

void List::delnode(int i) //删除第 i 个节点

{

nodetype *h=head, *p=head, *s;

int j=1;

if(i==1) //删除第一个节点

{

h=h->next;

free(p);

}

else

{

p=findnode(i-1); //查找第 i-1 个节点，并由 p 指向这个节点

if(p!=NULL && p->next!=NULL)

{

s=p->next; // s 指向要删除的节点

p->next=s->next;

free(s);

}

else

cout<<"输入的 i 值不正确"<

}

head=h;

}

void List::editperson(nodetype* p)

{

char c[100];

cout<<"请输入姓名: "<

cin>>c;

strcat(c, "\n");

strcpy(p->pe.name, c);

cout<<"请输入性别："<

cin>>c;

strcat(c, "\n");

strcpy(p->pe.sex, c);

cout<<"请输入生日（格式举例：1982-1-1）: "<

cin>>c;

strcat(c, "\n");

strcpy(p->birthday, c);

cout<<"请输入民族："<

cin>>c;

strcat(c, "\n");

strcpy(p->pe.MZ, c);

cout<<"请输入国籍："<

cin>>c;

strcat(c, "\n");

strcpy(p->pe.GJ, c);

cout<<"请输入学历："<

cin>>c;

strcat(c, "\n");

strcpy(p->pe.XL, c);

cout<<"请输入家庭住址（例如：广西玉林市解放路11号"<

cin>>c;

strcat(c, "\n");

strcpy(p->address, c);

cout<<"编辑个人信息完成!"<

dispperson(p);

}

void List::editscore(nodetype* p)

{

char a[50];

cout<<"请输入学号: "<

cin>>a;

strcat(a, "\n");

strcpy(p->sc.num, a);

cout<<"请输入大学语文成绩: "<

cin>>a;

strcat(a, "\n");

strcpy(p->sc.chinese, a);

cout<<"请输入英语成绩: "<

cin>>a;

strcat(a, "\n");

strcpy(p->sc.english, a);

cout<<"请输入数学成绩: "<

cin>>a;

strcat(a, "\n");

strcpy(p->sc.math, a);

cout<<"请输入物理成绩: "<

cin>>a;

strcat(a, "\n");

strcpy(p->sc.physics, a);

cout<<"编辑学科成绩完成!"<

dispscore(p);

}

void List::edittelephone(nodetype* p)

{

char c[50];

cout<<"请输入手机号码: "<

cin>>c;

strcat(c, "\n");

strcpy(p->te.SJ, c);

cout<<"请输入家庭电话号码: "<

cin>>c;

strcat(c, "\n");

strcpy(p->te.JD, c);

cout<<"请输入学校电话号码: "<

cin>>c;

strcat(c, "\n");

strcpy(p->te.XD, c);

cout<<"编辑联系方式完成!"<

disptelephone(p);

}

void List::dispperson(nodetype* p)

{

cout<<"姓名: "<pe.name;

cout<<"性别: "<pe.sex;

cout<<"民族: "<pe.MZ;

cout<<"国籍: "<pe.GJ;

cout<<"学历: "<pe.XL;

cout<<"出生日期: "<birthday;

cout<<"家庭住址: "<address;

}

void List::dispscore(nodetype* p)

{

cout<<"学号: "<sc.num;

cout<<"大学语文成绩: "<sc.chinese;

cout<<"英语成绩: "<sc.english;

cout<<"数学成绩: "<sc.math;

cout<<"物理成绩: "<sc.physics;

}

void List::disptelephone(nodetype* p)

{

cout<<"手机号码是: "<te.SJ;

cout<<"家庭电话是: "<te.JD;

cout<<"学校电话是: "<te.XD;

}

void List::help()

{

cout<

cout<<"*********************************************************"<

cout<<"1: 编辑个人信息"<

cout<<"2: 编辑学科成绩"<

cout<<"3: 编辑联系方式"<

cout<<"4: 显示个人信息"<

cout<<"5: 显示学科成绩"<

cout<<"6: 显示联系方式"<

cout<<"7: 显示该学生所有信息"<

cout<<"8: 帮助菜单"<

cout<<"9: 返回上一级菜单"<

cout<<"*********************************************************"<

}

List::~List()

{

nodetype *pa=head, *pb;

if(pa!=NULL)

{

pb=pa->next;

if(pb==NULL)

free(pa);

else

{

while(pb!=NULL)

{

free(pa);

pa=pb;

pb=pb->next;

}

free(pa);

}

}

}

3、从模块构成、代码组成、各模块的关系、数据结构规范等方面说明一个软件系统的构建方法。

答：软件系统总体应包含两方面的内容。由系统中所有过程性部件构成的层次结构，对应于程序结构的输入输出数据结构。模块应该设计的使所含信息（过程和数据）对于那些不需要这些信息的模块不可访问，每个模块只完成一个相对独立的特定的功能。模块之间仅仅交换那些为完成系统功能必须交换的信息，即模块应该独立。之后生成代码。如果一个模块控制另一个模块，称前者为“主控”模块，后者为“从属”模块。数据结构对程序结构和过程复杂性有直接地影响。数据结构需要通过进行算法复杂性分析，综合各种因素之后才能选出最佳方案。从而构建一个软件系统。