软件工程基础实训指导.docx
《软件工程基础实训指导.docx》由会员分享，可在线阅读，更多相关《软件工程基础实训指导.docx（67页珍藏版）》请在冰豆网上搜索。
软件工程基础实训指导
软件工程基础实训
指导书
田军营仲志丹
河南科技大学机电工程学院
线性表的基本运算
一、实训学时：
2学时
二、实训目的：
理解线性表的概念，掌握线性表的存储方法以及建立在该存储方法上的各种线性表算法，并用C/C++调试实现。
三、实训原理：
线性表是一种数据结构，它有多种存储方法，不同存储方法对应的线性表算法都有着相同的功能和不同的实现。
学生实验时，线性表的存储结构可以通过数组和链表来实现，而线性表的各种算法则就是为实现相同功能而进行的数组或链表操作。
四、实训设备：
一台可以建立C/C++语言程序调试环境的个人计算机。
五、主要实训内容及编程：
１、线性表的各种存储结构的实训
相关线性表实训的前提必须使学生掌握并理解线性表的概念，并搞清楚什么是数据结构。
数据结构不仅仅与数据的存储结构有关，同时与相关存储结构的算法有关。
数据结构=数据的结构+算法。
所以，线性表的存储结构十分重要。
当然，线性表的存储结构有许多种，比如数组、链表等。
下面给出一例：
#defineListSize20
//Liststructure
typedefintDataType;//DataType的类型可根据实际情况而定，这里假设为int
typedefstruct{
DataTypedata[ListSize];//向量data用于存放表结点
intlength;//当前的表长度
}seqList;
显然，在一个线性表的存储结构中，线形表的尺寸（大小）、数据类型、结构形式都是要反映的内容。
2、基于某种线性表存储结构给出线形表操作的各种算法实训
各种算法实训参照下面参考程序进行：
#include
#include
#defineListSize20
//Liststructure
typedefintDataType;//DataType的类型可根据实际情况而定，这里假设为int
typedefstruct{
DataTypedata[ListSize];//向量data用于存放表结点
intlength;//当前的表长度
}seqList;
//menu
voidmenu（）{
printf（"\nCreateandInitalist:
->1\n"）;
printf（"Getthelength:
->2\n"）;
printf（"Gettheithnode:
->3\n"）;
printf（"Findthenode=x:
->4\n"）;
printf（"Insertthenodex:
->5\n"）;
printf（"Deletethenodex:
->6\n"）;
printf（"Yourchoiceis:
"）;}
//Createandinitalist
seqList*Init_seqlist（）{
//intnum;
inti=0;
seqList*list;
list=（seqList*）malloc（sizeof（seqList））;
//从键盘输入
/*
printf（"pleaseinputtheseqnumber:
"）;
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;
returnlist;}
//outputthelist
voidoutput_seqlist（seqList*list）{
inti=0;
printf（"Thesequenceis:
"）;
while（list->data[i]!
=-1）
printf（"%d",list->data[i++]）;
printf（"\n"）;}
//getlengthofthelist
intlength_seqlist（seqList*list）{
returnlist->length;}
//getthenodeofiinthelist
voidgetnode_seqlist（seqList*list）{
inti;
printf（"i="）;
scanf（"%d",&i）;
printf（"list->data[%d]=%d\n",i,list->data[i]）;}
//findnodeinthelist
voidfindnode_seqlist（seqList*list）{
intfound=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（"Notfound!
\n"）;
elseprintf（"Found!
i=%d\n",--i）;
}
//insertanodeintothelist
voidinsert_seqlist（seqList*list）{
inti,x;
printf（"insertx="）;
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++;}
//deleteanodeofthelist
voiddelete_seqlist（seqList*list）{
intx,i=0;
printf（"deletex="）;
scanf（"%d",&x）;
while（list->data[i]!
=x）{if（i==list->length）{printf（"nosuchnode=%dinthesequence!
\n",x）;
return;}
i++;}
if（list->data[i]==x）{for（i;ilength;i++）{list->data[i]=list->data[i+1];}
list->length--;}
}
voidmain（）
{
intn;
seqList*list;
menu（）;
while
（1）{printf（"Yourchoiceis:
"）;
scanf（"%d",&n）;
switch（n）{case1:
{list=Init_seqlist（）;
output_seqlist（list）;
break;}
case2:
{printf（"thelengthoflistis%d\n",length_seqlist（list））;
break;}
case3:
{getnode_seqlist（list）;
break;}
case4:
{findnode_seqlist（list）;
break;}
case5:
{insert_seqlist（list）;
output_seqlist（list）;
break;}
case6:
{delete_seqlist（list）;
output_seqlist（list）;
break;}
}
}
}
例子2：
#include
#include
typedefintelemType;
/************************************************************************/
/*以下是关于线性表顺序存储操作的16种算法*/
/************************************************************************/
structList{
elemType*list;
intsize;
intmaxSize;
};
voidagainMalloc（structList*L）
{
/*空间扩展为原来的2倍，并由p指针所指向，原内容被自动拷贝到p所指向的存储空间*/
elemType*p=realloc（L->list,2*L->maxSize*sizeof（elemType））;
if（!
p）{/*分配失败则退出运行*/
printf（"存储空间分配失败！
"）;
exit
（1）;
}
L->list=p;/*使list指向新线性表空间*/
L->maxSize=2*L->maxSize;/*把线性表空间大小修改为新的长度*/
}
/*1.初始化线性表L，即进行动态存储空间分配并置L为一个空表*/
voidinitList（structList*L,intms）
{
/*检查ms是否有效，若无效的则退出运行*/
if（ms<=0）{
printf（"MaxSize非法！
"）;
exit
（1）;/*执行此函数中止程序运行，此函数在stdlib.h中有定义*/
}
L->maxSize=ms;/*设置线性表空间大小为ms*/
L->size=0;
L->list=malloc（ms*sizeof（elemType））;
if（!
L->list）{
printf（"空间分配失败！
"）;
exit
（1）;
}
return;
}
/*2.清除线性表L中的所有元素，释放存储空间，使之成为一个空表*/
voidclearList（structList*L）
{
if（L->list!
=NULL）{
free（L->list）;
L->list=0;
L->size=L->maxSize=0;
}
return;
}
/*3.返回线性表L当前的长度，若L为空则返回０*/
intsizeList（structList*L）
{
returnL->size;
}
/*4.判断线性表L是否为空，若为空则返回1,否则返回0*/
intemptyList（structList*L）
{
if（L->size==0）{
return1;
}
else{
return0;
}
}
/*5.返回线性表L中第pos个元素的值，若pos超出范围，则停止程序运行*/
elemTypegetElem（structList*L,intpos）
{
if（pos<1||pos>L->size）{/*若pos越界则退出运行*/
printf（"元素序号越界！
"）;
exit
（1）;
}
returnL->list[pos-1];/*返回线性表中序号为pos值的元素值*/
}
/*6.顺序扫描（即遍历）输出线性表L中的每个元素*/
voidtraverseList（structList*L）
{
inti;
for（i=0;isize;i++）{
printf（"%d",L->list[i]）;
}
printf（""）;
return;
}
/*7.从线性表L中查找值与x相等的元素，若查找成功则返回其位置，否则返回-1*/
intfindList（structList*L,elemTypex）
{
inti;
for（i=0;isize;i++）{
if（L->list[i]==x）{
returni;
}
}
return-1;
}
/*8.把线性表L中第pos个元素的值修改为x的值，若修改成功返回1，否则返回0*/
intupdatePosList（structList*L,intpos,elemTypex）
{
if（pos<1||pos>L->size）{/*若pos越界则修改失败*/
return0;
}
L->list[pos-1]=x;
return1;
}
/*9.向线性表L的表头插入元素x*/
voidinserFirstList（structList*L,elemTypex）
{
inti;
if（L->size==L->maxSize）{
againMalloc（L）;
}
for（i=L->size-1;i>=0;i--）{
L->list[i+1]=L->list[i];
}
L->list[0]=x;
L->size++;
return;
}
/*10.向线性表L的表尾插入元素x*/
voidinsertLastList（structList*L,elemTypex）
{
if（L->size==L->maxSize）{/*重新分配更大的存储空间*/
againMalloc（L）;
}
L->list[L->size]=x;/*把x插入到表尾*/
L->size++;/*线性表的长度增加１*/
return;
}
/*11.向线性表L中第pos个元素位置插入元素x，若插入成功返回１，否则返回０*/
intinsertPosList（structList*L,intpos,elemTypex）
{
inti;
if（pos<1||pos>L->size+1）{/*若pos越界则插入失败*/
return0;
}
if（L->size==L->maxSize）{/*重新分配更大的存储空间*/
againMalloc（L）;
}
for（i=L->size-1;i>=pos-1;i--）{
L->list[i+1]=L->list[i];
}
L->list[pos-1]=x;
L->size++;
return1;
}
/*12.向有序线性表L中插入元素x, 使得插入后仍然有序*/
voidinsertOrderList（structList*L,elemTypex）
{
inti,j;
/*若数组空间用完则重新分配更大的存储空间*/
if（L->size==L->maxSize）{
againMalloc（L）;
}
/*顺序查找出x的插入位置*/
for（i=0;isize;i++）{
if（xlist[i]）{
break;
}
}
/*从表尾到下标i元素依次后移一个位置，把i的位置空出来*/
for（j=L->size-1;j>=i;j--）
L->list[j+1]=L->list[j];
/*把x值赋给下标为i的元素*/
L->list[i]=x;
/*线性表长度增加1*/
L->size++;
return;
}
/*13.从线性表L中删除表头元素并返回它，若删除失败则停止程序运行*/
elemTypedeleteFirstList（structList*L）
{
elemTypetemp;
inti;
if（L->size==0）{
printf（"线性表为空，不能进行删除操作！
"）;
exit
（1）;
}
temp=L->list[0];
for（i=1;isize;i++）
L->list[i-1]=L->list[i];
L->size--;
returntemp;
}
/*14.从线性表L中删除表尾元素并返回它，若删除失败则停止程序运行*/
elemTypedeleteLastList（structList*L）
{
if（L->size==0）{
printf（"线性表为空，不能进行删除操作！
"）;
exit
（1）;
}
L->size--;
returnL->list[L->size];/*返回原来表尾元素的值*/
}
/*15.从线性表L中删除第pos个元素并返回它，若删除失败则停止程序运行*/
elemTypedeletePosList（structList*L,intpos）
{
elemTypetemp;
inti;
if（pos<1||pos>L->size）{/*pos越界则删除失败*/
printf（"pos值越界，不能进行删除操作！
"）;
exit
（1）;
}
temp=L->list[pos-1];
for（i=pos;isize;i++）
L->list[i-1]=L->list[i];
L->size--;
returntemp;
}
/*16.从线性表L中删除值为x的第一个元素，若成功返回1，失败返回0*/
intdeleteValueList（structList*L,elemTypex）
{
inti,j;
/*从线性表中顺序查找出值为x的第一个元素*/
for（i=0;isize;i++）{
if（L->list[i]==x）{
break;
}
}
/*若查找失败，表明不存在值为x的元素，返回0*/
if（i==L->size）{
return0;
}
/*删除值为x的元素L->list[i]*/
for（j=i+1;jsize;j++）{
L->list[j-1]=L->list[j];
}
L->size--;
return1;
}
/************************************************************************/
intmain（）
{
inta[10]={2,4,6,8,10,12,14,16,18,20};
inti;
structListL;
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）;
return0;
}
算法时间复杂性主要是根据算法中的关键计算的次数来评价的。
数据排序与查找
一、实训学时：
2学时
二、实训目的：
学习和理解数据排序和查找的不同实现方法，了解实现它们的技巧和方法。
三、实训原理：
任选一种排序和查找算法用C/C++实现，通过实验说明它们的复杂度以及适用范围。
四、实训设备：
一台可以建立C/C++语言程序调试环境的个人计算机。
五、主要实训内容及编程：
１、数据排序算法实训。
数据排序算法实训参照参考程序进行。
2、数据查找算法实训
数据查找算法实训参照参考程序进行。
参考程序1：
冒泡排序
#include"stdio.h"
voidpcbub（p,n）
intn;
charp[];
{intm,k,j,i;
chard;
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;
staticcharp[]={'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"）;
}
参考程序2：
堆排序
#include"stdio.h"
voidpchap（p,n）
intn;
charp[];
{inti,mm;
chart;
voidcsift（）;
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;
}
staticvoidcsift（p,
升级会员 