数据结构课程设计Word文档下载推荐.docx
- 文档编号:18957388
- 上传时间:2023-01-02
- 格式:DOCX
- 页数:36
- 大小:417.98KB
数据结构课程设计Word文档下载推荐.docx
《数据结构课程设计Word文档下载推荐.docx》由会员分享,可在线阅读,更多相关《数据结构课程设计Word文档下载推荐.docx(36页珍藏版)》请在冰豆网上搜索。
(4)重复执行第
(2)、(3)步,直到所有数据元素被输出。
●归并排序
假设初始排序表有n个数据元素,首先把它看成是长度为1的首尾相接的n个有序子表(以后称它们为归并项),先做两两归并,得n/2个长度为2的归并项(如果n为奇数,则最后一个归并项的长度为1);
再做两两归并,……,如此重复,最后得到一个长度为n的有序序列。
2.主要的数据结构设计说明
用顺序表作为排序表的抽象数据类型;
另外还包括7个排序函数的模板类
3.程序的主要流程图
4.程序的主要模块,要求对主要流程图中出现的模块进行说明
template<
classType>
classsortlist;
//对函数的操作
classelement;
//数据元素关键字及其他信息
voidmerge(sortlist<
Type>
&
sourcetable,sortlist<
mergedtable,constintleft,constintmid,constintright);
//归并
voidmergepass(sortlist<
mergedtable,constintlen);
//一趟归并
voidmergesort(sortlist<
table);
//两路归并
voidBubbleSort(sortlist<
table)//冒泡排序
voidQuickSort(sortlist<
table,intlow,inthigh)//快速排序
voidInsertion(sortlist<
table)//直接插入排序
voidBinaryInsert(sortlist<
table)//折半插入排序
voidselectsort(sortlist<
table)//选择排序
voidsift(sortlist<
table,intlow,inthigh)//堆排序调整
voidheapSort(sortlist<
table,intn)//堆排序
5.程序的主要函数及其伪代码说明(不需要完整的代码)
✧sortlist构造函数
sortlist(TypeA[],intd)
{
Arr=newelement<
[d];
for(inti=0;
i<
d;
i++)
{
Arr[i].key=A[i];
}
CurrentSize=d;
}
✧交换函数
voidswap(element<
x,element<
y)
element<
temp=x;
x=y;
y=temp;
✧输出函数
voidprint()
CurrentSize;
cout<
<
(Arr+i)->
getKey()<
"
"
;
cout<
endl;
✧归并排序模板类
a)归并
voidmerge(sortlist<
mergedtable,constintleft,constintmid,constintright)
inti=left,j=mid+1,k=left;
while(i<
=mid&
j<
=right)
{
if(sourcetable.Arr[i].getKey()<
=sourcetable.Arr[j].getKey())
{mergedtable.Arr[k]=sourcetable.Arr[i];
i++;
k++;
else
{mergedtable.Arr[k]=sourcetable.Arr[j];
j++;
}
if(i<
=mid)
for(intp=k,q=i;
q<
=mid;
p++,q++)
mergedtable.Arr[p]=sourcetable.Arr[q];
for(intp=k,q=j;
=right;
b)一趟归并
mergedtable,constintlen)
inti=0;
while(i+2*len<
CurrentSize-1)
merge(sourcetable,mergedtable,i,i+len-1,i+2*len-1);
i+=2*len;
if(i+len<
=CurrentSize-1)
merge(sourcetable,mergedtable,i,i+len-1,CurrentSize-1);
elsefor(intj=i;
=CurrentSize-1;
j++)mergedtable.Arr[j]=sourcetable.Arr[j];
for(intj=0;
j++)
sourcetable.Arr[j]=mergedtable.Arr[j];
c)二路归并
voidmergesort(sortlist<
table)
cout<
归并排序:
sortlist<
type>
temptable;
intlen=1;
intu=1;
while(len<
table.CurrentSize)
mergepass(table,temptable,len);
len*=2;
第"
u<
趟排序结果是:
u++;
print();
✧冒泡排序
table)
cout<
冒泡排序:
inti=1;
intfinish=0;
ints=0,t=0;
while(i<
table.CurrentSize&
!
finish)
t++;
finish=1;
for(intj=0;
table.CurrentSize-i;
if(table.Arr[j].getKey()>
table.Arr[j+1].getKey())
{
swap(table.Arr[j],table.Arr[j+1]);
finish=0;
s++;
趟排序结果为:
table.print();
移动次数"
s<
"
比较次数"
t<
};
✧快速排序
table,intlow,inthigh)
inti=low,j=high;
staticinty(0);
element<
temp=table.Arr[low];
if(i<
j)
q++;
while(i<
j){
q++;
while(i<
j&
temp.getKey()<
table.Arr[j].getKey())j--;
if(i<
j){table.Arr[i]=table.Arr[j];
i++;
q++;
p++;
temp.getKey()>
=table.Arr[i].getKey())i++;
j){table.Arr[j]=table.Arr[i];
j--;
p++;
table.Arr[i]=temp;
QuickSort(table,low,i-1);
QuickSort(table,i+1,high);
++y<
table,intn)
快速排序"
QuickSort(table,0,n-1);
移动次数="
p<
比较次数="
✧直接插入排序
直接插入排序"
temp;
intj;
for(inti=1;
table.CurrentSize;
i++){
temp=table.Arr[i];
j=i;
while(j>
0&
table.Arr[j-1].getKey())
{table.Arr[j]=table.Arr[j-1];
t++;
j--;
table.Arr[j]=temp;
s++;
✧折半插入排序
折半插入排序:
intleft,right;
left=0;
right=i-1;
temp=table.Arr[i];
s++;
while(left<
=right){
t++;
intmid=(right+right)/2;
if(temp.getKey()<
table.Arr[mid].getKey()){right=mid-1;
else{left=mid+1;
}}
for(intk=i-1;
k>
=left;
k--)
{table.Arr[k+1]=table.Arr[k];
table.Arr[left]=temp;
table.print();
✧简单选择排序
table)
简单选择排序:
intk;
ints(0),n(0);
for(inti=0;
table.CurrentSize-1;
k=i;
for(intj=i+1;
s++;
if(table.Arr[j].getKey()<
table.Arr[k].getKey())
{
k=j;
}
}
if(k!
=i)
swap(table.Arr[i],table.Arr[k]);
n++;
i+1<
table.print();
n<
✧堆排序
table,intlow,inthigh)
{
inti=low;
intj=2*i+1;
while(j<
=high)
if(j<
high&
table.Arr[j].getKey()<
table.Arr[j+1].getKey())
j++;
if(temp.getKey()<
table.Arr[j].getKey())
table.Arr[i]=table.Arr[j];
i=j;
j=2*i+1;
p++;
j=high+1;
table.Arr[i]=temp;
p++;
voidheapSort(sortlist<
table,intn)
staticintg
(1);
堆排序"
inti;
for(i=n/2-1;
i>
=0;
i--)
sift(table,i,n-1);
g++<
趟结果为:
for(i=n-1;
0;
element<
temp=table.Arr[0];
table.Arr[0]=table.Arr[i];
table.Arr[i]=temp;
sift(table,0,i-1);
三、上机结果及体会
1.实际完成的情况说明(完成的功能,支持的数据类型等)
全部可以实现排序;
归并排序和快速排序的输出趟数可能会有小的误差。
本段程序支持整数类型的排序;
2.程序的性能分析,包括时空分析;
●冒泡序
时间复杂度
a)最好情况(正序)
b)比较次数:
n-1(只要进行一趟即可)
c)移动次数:
d)最坏情况(逆序)
比较次数:
(需n-1趟,每趟达到最大比较次数)
移动次数:
空间复杂度:
S(n)=O
(1)
稳定性:
冒泡排序算法是一种稳定的排序方法
最好情况(每次总是选到中间值作枢轴)T(n)=O(nlog2n)
最坏情况(每次总是选到最小或最大元素作枢轴)T(n)=O(n²
)
需栈空间以实现递归
•最坏情况:
S(n)=O(n)
•一般情况:
S(n)=O(log2n)
•快速排序是一种不稳定的排序方法。
时间复杂度
1.若待排序记录按关键字从小到大排列(正序)
1关键字比较次数:
2记录移动次数:
2(n-1)
2.若待排序记录按关键字从大到小排列(逆序)
3.若待排序记录是随机的,取最好和最坏情况的平均值
1关键字比较次数(约为):
2记录移动次数(约为):
T(n)=O(n²
直接插入排序是一种稳定的排序方法
就平均性能而言,因为折半查找优于顺序查找,所以折半插入排序也优于直接插入排序。
折半插入排序的算法只能在顺序表存储结构下实现。
折半插入排序是一个稳定的排序方法。
比较次数=(n-1)+(n-2)+…+1=n(n-1)/2
当这组数据元素的初始状态是按其关键字从小到大有序的时候,数据元素的移动次数为0,达到最小值;
直接选择排序总的时间复杂度为O(n2)。
直接选择排序总的空间复杂度为S
(1)。
直接选择排序是一种不稳定的排序方法。
堆排序的时间复杂性为O(nlog2n)。
该算法的空间复杂性为O
(1)。
堆排序是一种不稳定的排序方法。
两路归并排序算法总的时间复杂度为O(nlog2n)。
两路归并排序占用附加存储较多,需要另外一个与原待排序数据元素数组同样大小的辅助数组,所以其空间复杂度为O(n)。
两路归并排序是一个稳定的排序方法。
3.打印程序运行时的初值和运行结果:
直接插入排序
折半插入排序
冒泡排序
简单选择排序
快速排序
堆排序
归并排序
4.上机过程中出现的问题及其解决方案
问题:
归并排序时缺少缺少第二趟的显示
解决方案:
只调用一次mergepass函数,具体代码下面:
voidmergepass(sortlist<
mergedtable,constintlen)
inti=0;
while(i+2*len<
{h++;
merge(sourcetable,mergedtable,i,i+len-1,i+2*len-1);
i+=2*len;
elsefor(intj=i;
//if(i+len<
merge(sourcetable,mergedtable,i,i+len-1,CurrentSize-1);
else
for(intj=i;
{h++;
l++;
mergedtable.Arr[j]=sourcetable.Arr[j];
intu=1;
mergepass(table,
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 数据结构 课程设计