数据结构课程设计 实验报告 心得体会 C++Word文件下载.docx
- 文档编号:22583300
- 上传时间:2023-02-04
- 格式:DOCX
- 页数:27
- 大小:314.04KB
数据结构课程设计 实验报告 心得体会 C++Word文件下载.docx
《数据结构课程设计 实验报告 心得体会 C++Word文件下载.docx》由会员分享,可在线阅读,更多相关《数据结构课程设计 实验报告 心得体会 C++Word文件下载.docx(27页珍藏版)》请在冰豆网上搜索。
2、选择排序:
selSort()
每一趟从待排序的数据元素中选出最小(或最大)的一个元素,顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。
选择排序不像冒泡排序算法那样先并不急于调换位置,第一轮(k=1)先从array[k]开始逐个检查,看哪个数最小就记下该数所在的位置于minlIndex中,等一轮扫描完毕,如果找到比array[k-1]更小的元素,则把array[minlIndex]和a[k-1]对调,这时array[k]到最后一个元素中最小的元素就换到了array[k-1]的位置。
如此反复进行第二轮、第三轮…直到循环至最后一元素
3、直接插入排序:
insSort()
在已经排好序的序列中查找待插入的元素的插入位置,并将待插入元素插入到有序列表中的过程。
将数组分成两部分,初始化时,前部分数组为只有第一个元素,用来存储已排序元素,我们这里叫arr1;
后部分数组的元素为除第一个元素的所有元素,为待排序或待插入元素,我们这里叫arr2。
排序时使用二层循环:
第一层对arr2进行循环,每次取后部分数组(待排序数组)里的第一个元素(我们称为待排序元素或称待插入元素)e1,然后在第二层循环中对arr1(已排好序的数组)从第一个元素往后进行循环,查到第一个大于待插入元素(如果是升序排列)或第一个小于待插入元素(如果是降序排列)e2,然后对arr1从e2元素开始往后的所有元素向后移,最后把e1插入到原来e2所在的位置。
这样反复地对arr2进行循环,直到arr2中所有的待插入的元素都插入到arr1中。
4、快序排序:
QuickSort()
基本思想:
首先在r[1..n]中,确定一个r[i],经过比较和
移动,将r[i]放到"
中间"
某个位置上,使得r[i]左边所有记录
的关键字小于等于r[i].key,r[i]右边所有记录的关键字大于等
于r[i].key。
以r[i]为界,将文件划分为左、右两个子文件。
用同样的方法分别对这两个子文件进行划分,得到4个更小
的子文件。
继续进行下去,使得每个子文件只有一个记录为止,
便得到原文件的有序文件。
例.给定文件(20,05,37,08,63,12,59,15,44,08),选
用第1个元素20进行划分:
5、归并排序:
MegeSort()
假定文件(r[1],r[2],...,r[n])中记录是随机排列的,进行
2-路归并排序,首先把它划分为长度均为1的n个有序子文件,
然后对它们逐步进行2-路归并排序。
其步骤如下:
第1趟:
从r[1..n]中的第1个和第2个有序子文件开始,调用
算法merge,每次归并两个相邻子文件,归并结果放到y[1..n]中。
在y中形成n/2个长度为2的有序子文件。
若n为奇数,则y中最
后一个子文件的长度为1。
把y[1..n]看作输入文件,将n/2个有序子文件两
两归并,归并结果回送到r[1..n]中,在r中形成n/2/2个长度为4的有序子文件。
若y中有奇数个子文件,则r中最后一个子文
件的长度为2。
共计经过log2n趟归并,最后得到n个记录的有序文件。
6、堆排序:
HeapSort()
堆实质上是满足如下性质的完全二叉树:
树中任一非叶结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字。
1、N(N>
1)个节点的的完全二叉树从层次从左自右编号,最后一个分枝节点(非叶子节点)的编号为N/2取整。
2、且对于编号i(1<
=i<
=N)有:
父节点为i/2向下取整;
若2i>
N,则节点i没有左孩子,否则其左孩子为2i;
若2i+1>
N,则没有右孩子,否则其右孩子为2i+1。
3、这里使用完全二叉树只是为了好描述算法,它只是一种逻辑结构,真真在实现时我们还是使用数组来存储这棵二叉树的,因为完全二叉树完全可以使用数组来存储。
堆排序其实最主要的两个过程:
第一步,创建初始堆;
第二步,交换根节点与最后一个非叶子节
从最后一个非叶子节点为开始向前循环每个会支节点,比较每个分支节点与他左右子节点,如果其中某个子节点比父节点大,则与父节点交换,交换后原父节点可能还小于原子节点的子节点,所以还需对原父节点进行调整,使用原父节点继续下沉,直到没有子节点或比左右子节点都大为止,调用过程可通过递归完成。
当某个非叶子节点调整完毕后,再处理下一个非叶子节点,直到根节点也调整完成,这里初始堆就创建好了,这里我们创建的是大顶堆,即大的元素向树的根浮,这样排序最后得到的结果为升序,因为最大的
将树中的最后一个元素与堆顶元素进行交换,并从树中去掉最后叶子节点。
交换后再按创建初始堆的算法调整根节点,如此下去直到树中只有一个节点为止。
四、算法的流程图
五、算法设计分析
冒泡排序算法分析:
(1)最好情况,待排序的文件已是有序文件:
只需要进行1趟排序,
共计比较关键字的次数为n-1
不交换记录。
(2)最坏情况,要经过n-1趟排序,
所需总的比较关键字的次数为
(n-1)+(n-2)+...+1=n(n-1)/2
交换记录的次数最多为
移动记录次数最多为
3n(n-1)/2。
(3)只需要少量中间变量作为辅助空间。
算法是稳定的。
选择排序算法分析:
(1)比较次数,在任何情况下,均为
(2)交换记录的次数
在最好情况下,原n个记录递增有序:
不移动记录。
在最坏情况下共交换记录n-1对,移动记录数3(n-1)次。
故,时间复杂度为O(n2)。
(3)只需少量中间变量作为辅助空间。
(4)算法是不稳定的。
直接插入排序算法分析:
故,时间复杂度为O(n2)。
(4)只需少量中间变量作为辅助空间。
(5)算法是稳定的。
QuickSort(d)
快速排序算法分析:
(1)就平均速度而言,
快速排序是已知内部排序方法中最好的一种排序方法,
其时间复杂度为
O(nlog(n))。
(2)在最坏情况下,
快速排序所需的比较次数和冒泡排序的比较次数相同,
O(n2)。
(3)快速排序需要一个栈作辅助空间,用来实现递归处理左、右子文件。
在最坏情况下,递归深度为n,
所需栈的空间大小为
O(n)。
(4)快速排序是不稳定的。
MegerSort()
归并排序算法分析:
(1)对n个记录的文件进行归并排序,共需
log2n趟,
(2)每趟所需比较关键字的次数不超过n,共比较
O(nlog2n)次。
(3)每趟移动n个记录,共移动记录
O(nlog2n)个
(4)归并排序需要一个大小为n的辅助空间
y[1..n]。
(5)归并排序是稳定的。
堆排序算法分析:
(1)堆排序的时间,主要由建立初始堆和反复重建堆这两部分的时间开销构成,
它们均是通过调用Heapify实现的。
(2)堆排序的最坏时间复杂度为
O(nlgn)。
(3)堆排序的平均性能较接近于最坏性能。
由于建初始堆所需的比较次数较多,所以堆排序不适宜于记录数较少的文件。
(4)堆排序是就地排序,辅助空间为
O
(1)。
(5)它是不稳定的排序方法
六、源代码
#include<
iostream.h>
time.h>
math.h>
iomanip.h>
#include<
stdlib.h>
//外部变量定义
intcount1=0,bj1=0,yd1=0;
intcount2=0,bj2=0,yd2=0;
intcount3=0,bj3=0,yd3=0;
intcount4=0,bj4=0,yd4=0;
intcount5=0,bj5=0,yd5=0;
intcount6=0,bj6=0,yd6=0;
clock_tstart1,finish1;
clock_tstart2,finish2;
clock_tstart3,finish3;
clock_tstart4,finish4;
clock_tstart5,finish5;
clock_tstart6,finish6;
intb[6]={finish1-start1,finish2-start2,finish3-start3,finish4-start4,finish5-start5,finish6-start6};
template<
classT>
classan
{
public:
voidselectsort(TA[],intn);
//简单选择排序
voidinsertsort(TA[],intn);
//直接插入排序
voidshellsort(TA[],intn);
//希尔排序
voidbubblesort(TA[],intn);
//冒泡排序
voidquicksort(TA[],intn);
//快速排序
voidmergesort(TA[],intn);
//两路合并排序
private:
voidmerge(TA[],inti1,intj1,inti2,intj2);
voidqsort(TA[],intleft,intright);
};
voidan<
T>
:
selectsort(TA[],intn)//简单选择排序
intsmall;
start3=clock();
for(inti=0;
i<
n-1;
i++)
{
small=i;
for(intj=i+1;
j<
n;
j++)
{
if(A[j]<
A[small])
small=j;
bj3++;
}
swap(A[i],A[small]);
count3++;
yd3+=3;
}
}
cout<
<
"
简单选择排序后的数组是:
endl;
for(i=0;
i++)
A[i]<
"
;
finish3=clock();
//直接插入排序
insertsort(TA[],intn)
start1=clock();
for(inti=1;
intj=i;
Ttemp=A[i];
while(j>
0&
&
temp<
A[j-1])
{
bj1++;
A[j]=A[j-1];
j--;
yd1++;
A[j]=temp;
直接插入排序后的数组是:
finish1=clock();
shellsort(TA[],intn)
start2=clock();
intj,tmp,jmp;
jmp=n/2;
while(jmp!
=0)
for(inti=jmp;
tmp=A[i];
j=i-jmp;
while(tmp<
A[j]&
j>
bj2++;
A[j+jmp]=A[j];
yd2++;
j=j-tmp;
A[jmp+j]=tmp;
jmp=jmp/2;
希尔排序后的数组是:
finish2=clock();
//冒泡排序
bubblesort(TA[],intn)
start4=clock();
inti=n-1,j,last;
while(i>
0)
last=0;
for(j=0;
i;
j++,i--)
if(A[j+1]<
A[j])
bj4++;
swap(A[j],A[j+1]);
count4++;
yd4+=3;
last=j;
i=last;
冒泡排序后的数组是:
finish4=clock();
//快速排序
quicksort(TA[],intn)
start5=clock();
qsort(A,0,n-1);
快速排序后的数组是:
finish5=clock();
qsort(TA[],intleft,intright)
inti,j;
if(left<
right)
i=left;
j=right+1;
do{
do{
i++;
bj5++;
}while(A[i]<
A[left]);
do{
}while(A[j]>
if(i<
j)
swap(A[i],A[j]);
count5++;
yd5+=3;
}while(i<
j);
swap(A[left],A[j]);
yd5+=3;
count5++;
qsort(A,left,j-1);
qsort(A,j+1,right);
//两路合并排序
merge(TA[],inti1,intj1,inti2,intj2)
T*temp=newT[j2-i1+1];
inti=i1,j=i2,k=0;
while(i<
=j1&
=j2)
if(A[i]<
=A[j])
temp[k++]=A[i++];
bj6++;
yd6++;
else
temp[k++]=A[j++];
=j1)
while(j<
=j2)
for(i=0;
k;
A[i1++]=temp[i];
delete[]temp;
mergesort(TA[],intn)
start6=clock();
inti1,j1,i2,j2;
intsize=1;
while(size<
n)
i1=0;
while(i1+size<
i2=i1+size;
j1=i2-1;
if(i2+size-1>
n-1)
j2=n-1;
elsej2=i2+size-1;
merge(A,i1,j1,i2,j2);
i1=j2+1;
size*=2;
两路合并排序后的数组是:
finish6=clock();
voidswap(T&
a,T&
b)
intc;
c=a;
a=b;
b=c;
}
voidmain()
an<
int>
p;
intrand(void);
//生成函数rand播种子的srand
intn,ch,x=78;
int*array;
cout<
*欢*迎*进*入*内*排*序*比*k较*系*统*"
请输入排序个数n!
!
cin>
>
array=newint[n];
for(inti=0;
i++)array[i]=rand()%n+1;
随机生成的原数组为:
i++)cout<
array[i]<
请选择排序方法或查看各种排序算法的性能比较!
0>
退出"
1>
直接插入排序"
2>
希尔排序"
3>
简单选择排序"
4>
冒泡排序"
5>
快速排序"
6>
两路合并排序"
7>
查看各种排序算法的性能比较"
ch;
switch(ch){
case1:
p.insertsort(array,n);
排序算法名称为:
直接插入排序!
时间复杂度o(n^2)为:
O("
n*n<
)"
数据量大小(多少个)为:
n<
比较次数为:
bj1<
平均移动次数为:
yd1<
交换次数为:
count1<
实际执行时间为:
finish1-start1<
break;
case2:
p.shellsort(array,n);
希尔排序!
时间复杂度O(n*log(2*n))为:
int(n*log(2*n))<
bj2<
yd2<
count2<
finish2-start2<
case3:
p.selectsort(array,n);
简单选择排序!
bj3<
yd3<
count3<
finish3-start3<
case4:
p.bubblesort(array,n);
冒泡排序!
比较次数<
为:
bj4<
yd4<
count4<
finish4-start4<
case5:
p.quicksort(array,n);
快速排序!
时间复杂度O(nlogn)为:
int(n*log(n))<
bj5<
yd5<
交换次数为
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 数据结构课程设计 实验报告 心得体会 C+ 数据结构 课程设计 实验 报告
![提示](https://static.bdocx.com/images/bang_tan.gif)