软件开发技术基础的实验报告Word下载.docx
- 文档编号:17383953
- 上传时间:2022-12-01
- 格式:DOCX
- 页数:25
- 大小:69.08KB
软件开发技术基础的实验报告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;
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 软件 开发 技术 基础 实验 报告