软件开发技术基础的实验报告Word下载.docx
《软件开发技术基础的实验报告Word下载.docx》由会员分享，可在线阅读，更多相关《软件开发技术基础的实验报告Word下载.docx（25页珍藏版）》请在冰豆网上搜索。
voidprt_sq_LList（）;
intflag_sq_LList（）;
voidins_sq_LList（int,T）;
voiddel_sq_LList（int）;
intsearch_sq_LList（Tx）;
};
sq_LList<
T>
:
sq_LList（intm）
mm=m;
v=newT[mm];
nn=0;
return;
voidsq_LList<
prt_sq_LList（）
inti;
cout<
<
"
nn="
nn<
endl;
for（i=0;
i<
nn;
i++）
cout<
v[i]<
intsq_LList<
flag_sq_LList（）
if（nn==mm）
return（-1）;
if（nn==0）
return（0）;
return
（1）;
ins_sq_LList（inti,Tb）
intk;
{
overflow"
return;
}
if（i>
nn）
i=nn+1;
if（i<
1）
i=1;
for（k=nn;
k>
=i;
k--）
v[k]=v[k-1];
v[i-1]=b;
nn=nn+1;
del_sq_LList（inti）
underflow!
if（（i<
1）||（i>
nn））
Notthiselementinthelist!
for（k=i;
k<
k++）
v[k-1]=v[k];
nn=nn-1;
search_sq_LList（Tx）
inti,j,k;
i=1;
j=nn;
while（i<
=j）
k=（i+j）/2;
if（v[k-1]==x）
cout<
你要查找的数现在的位置为:
（k-1）<
if（v[k-1]>
x）
j=k-1;
elsei=k+1;
return（0）;
intmain（）
inty;
sq_LList<
double>
a（100）;
第一次输出顺序表对象a:
a.prt_sq_LList（）;
a.ins_sq_LList（1,1）;
a.ins_sq_LList（2,3）;
a.ins_sq_LList（3,5）;
a.ins_sq_LList（4,7）;
a.ins_sq_LList（5,9）;
a.ins_sq_LList（6,11）;
第二次输出顺序表对象a:
a.del_sq_LList
（2）;
第三次输出顺序表对象a:
请输入要查找的数:
cin>
>
y;
a.search_sq_LList（y）;
第四次输出顺序表对象a:
return0;
运行结果如下：
心得体会：
1.通过本次试验，我掌握了线性表的基本概念。
2.通过本次试验，我懂得了如何建立一个顺序表，并能对顺序表进行基本的建立、插入、检测、删除以及查找的操作。
3.本次试验我知道了线性表的顺序存储结构具有如下两个特点：
（1）线性表中所有元素所占的存储空间是连续的。
（2）线性表中各元素在存储空间中是按逻辑顺序依次存放的。
实验二栈、队列的操作
实验目的：
参照给定的栈类和队列类的程序样例，验证给出的栈和队列的常见算法，并结合线性表类实现有关串的操作。
实验内容：
1．掌握栈、队列、串的特点。
掌握特殊线性表的常见算法。
2．提交实验报告，报告内容包括：
3.栈和队列的长度都由自己定；
4.写出完整的程序并能调试通过即可。
5．重点理解栈、队列和串的算法思想，能够根据实际情况选择合适的存储结构。
6栈、队列的算法是后续实验的基础（树、图、查找、排序等）。
实验原理：
1.堆栈类测试和应用问题。
要求：
定义数据元素的数据类型为如下形式的结构体：
typedefstruct
{chartaskname[10];
//任务名
inttaskno;
//任务号
｝DataType；
设计一个包含5个数据元素的测试数据，并设计一个主函数实现依次把5个数据元素入栈，然后出栈堆栈中的数据元素并在屏幕上显示。
2.队列类测试和应用问题。
设计一个主函数对循环队列类和链式队列类代码进行测试.测试方法为：
依次把数据元素1,2,3,4,5入队，然后出队中的数据元素并在屏幕上显示。
#include<
//stack--------------------------------------------begin
#definestacksize5
//任务名
//任务号
}DataType;
classstack
private:
inttop;
DataTypetask[stacksize];
public:
boolinit（）;
boolempty（）;
boolpush（DataTyped）;
boolpop（DataType&
d）;
boolstack:
init（）
top=0;
stacksize;
strcpy（task[i].taskname,"
）;
task[i].taskno=-1;
returntrue;
empty（）
returntop>
0?
false:
true;
push（DataTyped）
if（top>
=stacksize）returnfalse;
strcpy（task[top].taskname,d.taskname）;
task[top].taskno=d.taskno;
top++;
pop（DataType&
d）
if（top<
=0）returnfalse;
strcpy（d.taskname,task[top-1].taskname）;
d.taskno=task[top-1].taskno;
top--;
//stack--------------------------------------------end
//queue--------------------------------------------begin
classqueue_node
intdata;
queue_node*next;
queue_node（）
data=0;
next=NULL;
queue_node（intd）
data=d;
classqueue
queue_node*front,*rear;
boolenqueue（intd）;
booldequeue（int&
boolqueue:
front=rear=newqueue_node;
returntrue;
if（front==rear）returntrue;
elsereturnfalse;
enqueue（intd）
rear->
next=newqueue_node（d）;
rear=rear->
next;
dequeue（int&
if（front==rear）returnfalse;
queue_node*p=front->
d=p->
data;
front->
next=p->
if（p==rear）rear=front;
deletep;
//queue--------------------------------------------end
#definequeuesize10
classsqqueue
int*base;
intfront;
intrear;
boolsqqueue:
base=（int*）malloc（queuesize*sizeof（int））;
if（!
base）returnfalse;
front=rear=0;
if（（rear+1）%queuesize==front）returnfalse;
base[rear]=d;
rear=（rear+1）%queuesize;
d=base[front];
front=（front+1）%queuesize;
voidmain（）
DataTypedd[5],tt;
chartn[]="
任务a"
;
5;
strcpy（dd[i].taskname,tn）;
tn[4]++;
dd[i].taskno=i+1;
stackmystack;
mystack.init（）;
mystack.push（dd[i]）;
入栈完成，按回车键继续……"
getchar（）;
while（mystack.pop（tt））
tt.taskname<
"
tt.taskno<
出栈完成，按回车键继续……"
queuemyqueue;
myqueue.init（）;
myqueue.enqueue（i+1）;
链队入队完成，按回车键继续……"
for（;
myqueue.dequeue（i）;
）
链队出队完成，按回车键继续……"
sqqueuemysqqueue;
mysqqueue.init（）;
mysqqueue.enqueue（i+1）;
循环队列入队完成，按回车键继续……"
mysqqueue.dequeue（i）;
循环队列出队完成，按回车键退出……"
实验步骤：
实验结果：
实验三查找算法实现（2学时）
参照各种查找算法程序样例，验证给出的查找常见算法。
1、掌握各种查找算法的特点，测试并验证查找的常见算法。
1.建立有序表，采用折半查找实现某一已知的关键字的查找。
2．利用折半查找算法在一个有序表中插入一个元素，并保持表的有序性。
classsL_List
sL_List（）{mm=0;
sL_List（int）;
intsearch_sL_List（T）;
intinsert_sL_List（int,T）;
voidprt_sL_List（）;
sL_List<
sL_List（intm）
intsL_List<
search_sL_List（Tx）
return（k-1）;
return（-1）;
insert_sL_List（intp,Tx）
溢出！
p=nn-1;
while（v[p]>
v[p+1]=v[p];
p=p-1;
v[p+1]=x;
voidsL_List<
prt_sL_List（）
intk,t,q,result;
inta[20]={10,20,30,40,50,60,70,80};
sL_List<
int>
s（20）;
for（k=0;
8;
s.insert_sL_List（k+1,a[k]）;
输出有序对象s:
s.prt_sL_List（）;
t;
你要查找的数在数组中的位置为:
result=s.search_sL_List（t）;
result<
请插入一个元素:
q;
s.insert_sL_List（k+1,q）;
插入后有序表变为:
实验结果如下：
1.通过这次试验，我知道了一些查找的基本方法，并且了解了折半查找的典型方法及技巧。
2.并且我掌握了利用折半法插入一个元素的方法。
3.常见问题在于在插入位置时，易混淆位置与数值的关系，以及c++中的一些基本定义方法易忘记。
实验四排序综合实验（3学时）
综合性
3学时
参照各种排序算法程序样例，验证给出的排序常见算法。
1、掌握各种排序算法的特点，测试并验证排序的常见算法。
输入一组关键字序列分别实现下列排序:
1.实现直接插入排序；
2.实现冒泡排序算法；
3.实现快速排序算法（取第一个记录或中间记录作为基准记录）；
4.快速排序的非递归算法；
5.堆排序。
把上述几种排序的算法编写成菜单，根据输入的数字不同执行对应的排序算法。
//实现简单插入排序
voidinsort（Tp[],intn）
intj,k;
Tt;
for（j=1;
j<
n;
j++）
t=p[j];
k=j-1;
while（（k>
=0）&
&
（p[k]>
t））
{
p[k+1]=p[k];
k=k-1;
}
p[k+1]=t;
//实现冒泡排序
voidbub（Tp[],intn）
intm,k,j,i;
Td;
k=0;
m=n-1;
while（k<
m）
j=m-1;
m=0;
for（i=k;
=j;
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>
i--）
if（p[i-1]>
p[i]）
p[i]=p[i-1];
p[i-1]=d;
k=i;
//实现快速排序
voidqck（Tp[],intn）
intm,i;
T*s;
if（n>
10）
i=split（p,n）;
qck（p,i）;
s=p+（i+1）;
m=n-（i+1）;
qck（s,m）;
else
bub（p,n）;
staticintsplit（Tp[],intn）
inti,j,k,l;
i=0;
j=n-1;
k=（i+j）/2;
if（（p[i]>
=p[j]）&
（p[j]>
=p[k]））
l=j;
elseif（（p[i]>
=p[k]）&
=p[j]））
l=k;
l=i;
t=p[l];
p[l]=p[i];
while（i!
while（（i<
j）&
=t））
j=j-1;
if（i<
j）
p[i]=p[j];
i=i+1;
while（（i<
（p[i]<
i=i+1;
if（i<
p[j]=p[i];
j=j-1;
p[i]=t;
return（i）;
//实现堆排序
voidhap（Tp[],intn）
inti,mm;
mm=n/2;
for（i=mm-1;
=0;
sift（p,i,n-1）;
for（i=n-1;
升级会员 