软件工程基础实训指导Word下载.docx

软件工程基础实训指导Word下载.docx

《软件工程基础实训指导Word下载.docx》由会员分享，可在线阅读，更多相关《软件工程基础实训指导Word下载.docx（67页珍藏版）》请在冰豆网上搜索。

）;

Getthelength:

2\n"

Gettheithnode:

3\n"

Findthenode=x:

4\n"

Insertthenodex:

5\n"

Deletethenodex:

6\n"

Yourchoiceis:

"

}

//Createandinitalist

seqList*Init_seqlist（）{

//intnum;

inti=0;

seqList*list;

list=（seqList*）malloc（sizeof（seqList））;

//从键盘输入

/*

pleaseinputtheseqnumber:

"

scanf（"

%d"

&

num）;

while（num!

=-1）{list->

data[i++]=num;

}

list->

data[i]=-1;

length=--i;

*/

//默认值

for（i=0;

i<

10;

i++）

data[i]=i*10;

length=i;

returnlist;

//outputthelist

voidoutput_seqlist（seqList*list）{

Thesequenceis:

while（list->

data[i]!

=-1）

%d"

list->

data[i++]）;

\n"

//getlengthofthelist

intlength_seqlist（seqList*list）{

returnlist->

length;

//getthenodeofiinthelist

voidgetnode_seqlist（seqList*list）{

inti;

i="

i）;

data[%d]=%d\n"

i,list->

data[i]）;

//findnodeinthelist

voidfindnode_seqlist（seqList*list）{

intfound=0,i=0,x;

x="

x）;

=-1）{

if（list->

data[i++]==x）{found=1;

break;

if（!

found）printf（"

Notfound!

elseprintf（"

Found!

i=%d\n"

--i）;

//insertanodeintothelist

voidinsert_seqlist（seqList*list）{

inti,x;

insertx="

data[list->

length+1]=-1;

for（i=list->

length-1;

i>

=0;

i--）{if（x<

data[i]）{list->

data[i+1]=list->

data[i];

else{list->

data[i+1]=x;

length++;

//deleteanodeofthelist

voiddelete_seqlist（seqList*list）{

intx,i=0;

deletex="

=x）{if（i==list->

length）{printf（"

nosuchnode=%dinthesequence!

x）;

return;

i++;

data[i]==x）{for（i;

i++）{list->

data[i]=list->

data[i+1];

length--;

voidmain（）

{

intn;

menu（）;

while

（1）{printf（"

n）;

switch（n）{case1:

{list=Init_seqlist（）;

output_seqlist（list）;

case2:

{printf（"

thelengthoflistis%d\n"

length_seqlist（list））;

case3:

{getnode_seqlist（list）;

case4:

{findnode_seqlist（list）;

case5:

{insert_seqlist（list）;

case6:

{delete_seqlist（list）;

例子2：

stdlib.h>

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指向新线性表空间*/

maxSize=2*L->

maxSize;

/*把线性表空间大小修改为新的长度*/

/*1.初始化线性表L，即进行动态存储空间分配并置L为一个空表*/

voidinitList（structList*L,intms）

/*检查ms是否有效，若无效的则退出运行*/

if（ms<

=0）{

MaxSize非法！

/*执行此函数中止程序运行，此函数在stdlib.h中有定义*/

maxSize=ms;

/*设置线性表空间大小为ms*/

size=0;

list=malloc（ms*sizeof（elemType））;

L->

list）{

空间分配失败！

return;

/*2.清除线性表L中的所有元素，释放存储空间，使之成为一个空表*/

voidclearList（structList*L）

if（L->

list!

=NULL）{

free（L->

list）;

list=0;

size=L->

maxSize=0;

/*3.返回线性表L当前的长度，若L为空则返回０*/

intsizeList（structList*L）

returnL->

size;

/*4.判断线性表L是否为空，若为空则返回1,否则返回0*/

intemptyList（structList*L）

size==0）{

return1;

else{

return0;

/*5.返回线性表L中第pos个元素的值，若pos超出范围，则停止程序运行*/

elemTypegetElem（structList*L,intpos）

if（pos<

1||pos>

size）{/*若pos越界则退出运行*/

元素序号越界！

list[pos-1];

/*返回线性表中序号为pos值的元素值*/

/*6.顺序扫描（即遍历）输出线性表L中的每个元素*/

voidtraverseList（structList*L）

inti;

for（i=0;

i<

i++）{

L->

list[i]）;

/*7.从线性表L中查找值与x相等的元素，若查找成功则返回其位置，否则返回-1*/

intfindList（structList*L,elemTypex）

list[i]==x）{

returni;

return-1;

/*8.把线性表L中第pos个元素的值修改为x的值，若修改成功返回1，否则返回0*/

intupdatePosList（structList*L,intpos,elemTypex）

size）{/*若pos越界则修改失败*/

list[pos-1]=x;

/*9.向线性表L的表头插入元素x*/

voidinserFirstList（structList*L,elemTypex）

size==L->

maxSize）{

againMalloc（L）;

for（i=L->

size-1;

i>

=0;

i--）{

list[i+1]=L->

list[i];

list[0]=x;

size++;

/*10.向线性表L的表尾插入元素x*/

voidinsertLastList（structList*L,elemTypex）

size==L->

maxSize）{/*重新分配更大的存储空间*/

list[L->

size]=x;

/*把x插入到表尾*/

size++;

/*线性表的长度增加１*/

/*11.向线性表L中第pos个元素位置插入元素x，若插入成功返回１，否则返回０*/

intinsertPosList（structList*L,intpos,elemTypex）

size+1）{/*若pos越界则插入失败*/

=pos-1;

list[i+1]=L->

/*12.向有序线性表L中插入元素x,　使得插入后仍然有序*/

voidinsertOrderList（structList*L,elemTypex）

inti,j;

/*若数组空间用完则重新分配更大的存储空间*/

/*顺序查找出x的插入位置*/

if（x<

list[i]）{

break;

/*从表尾到下标i元素依次后移一个位置，把i的位置空出来*/

for（j=L->

j>

=i;

j--）

list[j+1]=L->

list[j];

/*把x值赋给下标为i的元素*/

list[i]=x;

/*线性表长度增加1*/

/*13.从线性表L中删除表头元素并返回它，若删除失败则停止程序运行*/

elemTypedeleteFirstList（structList*L）

elemTypetemp;

if（L->

size==0）{

线性表为空，不能进行删除操作！

temp=L->

list[0];

for（i=1;

i++）

list[i-1]=L->

size--;

returntemp;

/*14.从线性表L中删除表尾元素并返回它，若删除失败则停止程序运行*/

elemTypedeleteLastList（structList*L）

returnL->

size];

/*返回原来表尾元素的值*/

/*15.从线性表L中删除第pos个元素并返回它，若删除失败则停止程序运行*/

elemTypedeletePosList（structList*L,intpos）

size）{/*pos越界则删除失败*/

pos值越界，不能进行删除操作！

list[pos-1];

for（i=pos;

/*16.从线性表L中删除值为x的第一个元素，若成功返回1，失败返回0*/

intdeleteValueList（structList*L,elemTypex）

/*从线性表中顺序查找出值为x的第一个元素*/

list[i]==x）{

/*若查找失败，表明不存在值为x的元素，返回0*/

if（i==L->

size）{

/*删除值为x的元素L->

list[i]*/

for（j=i+1;

j<

j++）{

list[j-1]=L->

intmain（）

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

structListL;

initList（&

L,5）;

10;

insertLastList（&

L,a[i]）;

insertPosList（&

L,11,48）;

L,1,64）;

getElem（&

L,1））;

traverseList（&

L）;

findList（&

L,10））;

updatePosList（&

L,3,20）;

L,3））;

deleteFirstList（&

deleteLastList（&

deletePosList（&

;

deletePosList（&

L,7）;

sizeList（&

L））;

emptyList（&

clearList（&

算法时间复杂性主要是根据算法中的关键计算的次数来评价的。

数据排序与查找

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

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

１、数据排序算法实训。

数据排序算法实训参照参考程序进行。

2、数据查找算法实训

数据查找算法实训参照参考程序进行。

参考程序1：

冒泡排序

#include"

stdio.h"

voidpcbub（p,n）

intn;

charp[];

{intm,k,j,i;

chard;

k=0;

m=n-1;

while（k<

m）

{j=m-1;

m=0;

for（i=k;

i<

=j;

if（p[i]>

p[i+1]）

{d=p[i];

p[i]=p[i+1];

p[i+1]=d;

m=i;

j=k+1;

for（i=m;

i>

i--）

if（p[i-1]>

p[i]）

p[i]=p[i-1];

p[i-1]=d;

k=i;

main（）

{char*s;

staticcharp[]={'

a'

'

s'

t'

b'

x'

e'

f'

h'

i'

'

g'

p'

'

q'

j'

c'

z'

y'

s=p+2;

%s\n"

p）;

pcbub（s,17）;

参考程序2：

堆排序

voidpchap（p,n）

{inti,mm;

chart;

voidcsift（）;

mm=n/2;

for（i=mm-1;

csift（p,i,n-1）;

for（i=n-1;

=1;

{t=p[0];

p[0]=p[i];

p[i]=t;

csift（p,0,i-1）;

staticvoidcsift（p,