c++数据结构实验链表排序.docx
《c++数据结构实验链表排序.docx》由会员分享，可在线阅读，更多相关《c++数据结构实验链表排序.docx（24页珍藏版）》请在冰豆网上搜索。
c++数据结构实验链表排序
1.实验要求
i.实验目的:
通过编程,学习、实现、对比各种排序算法,掌握各种排序算法的优劣,以及各种算法使用的情况。
理解算法的主要思想及流程。
ii.实验内容:
使用链表实现下面各种排序算法,并进行比较。
排序算法:
1、插入排序
2、冒泡排序（改进型冒泡排序）
3、快速排序
4、简单选择排序
5、堆排序（小根堆）
要求:
1、测试数据分成三类:
正序、逆序、随机数据
2、对于这三类数据,比较上述排序算法中关键字的比较次数与移动次数（其中关键字交换计为3次移动）。
3、对于这三类数据,比较上述排序算法中不同算法的执行时间,精确到微秒（选作）
4、对2与3的结果进行分析,验证上述各种算法的时间复杂度
编写测试main（）函数测试线性表的正确性
iii.代码要求:
1、必须要有异常处理,比如删除空链表时需要抛出异常;
2、保持良好的编程的风格:
代码段与段之间要有空行与缩近
标识符名称应该与其代表的意义一致
函数名之前应该添加注释说明该函数的功能
关键代码应说明其功能
3、递归程序注意调用的过程,防止栈溢出
2、程序分析
通过排序算法将单链表中的数据进行由小至大（正向排序）
2、1存储结构
单链表存储数据:
structnode
{
intdata;
node*next;
};
单链表定义如下:
classLinkList
{
private:
node*front;
public:
LinkList（inta[],intn）;//构造
~LinkList（）;
voidinsert（node*p,node*s）;//插入
voidturn（node*p,node*s）;//交换数据
voidprint（）;//输出
voidInsertSort（）;//插入排序
voidBubbleSort（）;//pos冒泡
voidQSort（）;//快速排序
voidSelectSort（）;//简单选择排序
node*Get（inti）;//查找位置为i的结点
voidsift（intk,intm）;//一趟堆排序
voidLinkList:
:
QSZ（node*b,node*e）;//快速排序的递归主体
voidheapsort（intn）;//堆排序算法
};
2.2关键算法分析:
1、直接插入排序:
首先将待排序数据建立一个带头结点的单链表。
将单链表划分为有序区与无序区,有序区只包含一个元素节点,依次取无序区中的每一个结点,在有序区中查找待插入结点的插入位置,然后把该结点从单链表中删除,再插入到相应位置。
分析上述排序过程,需设一个工作指针p->next在无序区中指向待插入的结点,在找到插入位置后,将结点p->next插在结点s与p之间。
voidLinkList:
:
InsertSort（）//将第一个元素定为初始有序区元素,由第二个元素开始依次比较
{
LARGE_INTEGERt1,t2,feq;
QueryPerformanceFrequency（&feq）;//每秒跳动次数
QueryPerformanceCounter（&t1）;//测前跳动次数
node*p=front->next;//要插入的节点的前驱
while（p->next）
{
node*s=front;//充分利用带头结点的单链表
while
（1）
{
comparef++;
if（p->next->datanext->data）//[P后继]比[S后继]小则插入
{
insert（p,s）;break;
}
s=s->next;
if（s==p）//若一趟比较结束,且不需要插入
{
p=p->next;break;
}
}
}
QueryPerformanceCounter（&t2）;//测后跳动次数
doubled=（（double）t2、QuadPart-（double）t1、QuadPart）/（（double）feq、QuadPart）;//时间差秒
cout<<"操作时间为:
"<}
2、快速排序:
主要通过轴值将数据从两端向中间进行比较,交换以实现排序。
通过递归的调用来实现整个链表数据的排序。
代码中选用了第一个元素作为轴值。
一趟排序的代码:
voidLinkList:
:
QSZ（node*b,node*e）
{
if（b->next==e||b==e）//排序完成
return;
node*qianqu=b;//轴点前驱
node*p=qianqu->next;
while（p!
=e&&p!
=e->next）
{
comparef++;
if（qianqu->next->data>p->next->data）//元素值小于轴点值,则将该元素插在轴点之前
{
if（p->next==e）//若该元素为e,则将其前驱设为e
e=p;
insert（p,qianqu）;
qianqu=qianqu->next;
}
elsep=p->next;
}
QSZ（b,qianqu）;//继续处理轴点左侧链表
QSZ（qianqu->next,e）;//继续处理轴点右侧链表
}
整个快速排序的实现:
voidLinkList:
:
QSort（）
{
LARGE_INTEGERt1,t2,feq;
QueryPerformanceFrequency（&feq）;//每秒跳动次数
QueryPerformanceCounter（&t1）;//测前跳动次数
node*e=front;
while（e->next）
{
e=e->next;
}
QSZ（front,e）;
QueryPerformanceCounter（&t2）;//测后跳动次数
doubled=（（double）t2、QuadPart-（double）t1、QuadPart）/（（double）feq、QuadPart）;//时间差秒
cout<<"操作时间为:
"<}
3、改进版的冒泡排序:
通过设置pos来记录无序边界的位置以减少比较次数。
将数据从前向后两两比较,遇到顺序不对就是直接交换两数据的值。
每交换一次movef+3;
voidLinkList:
:
BubbleSort（）
{
LARGE_INTEGERt1,t2,feq;
QueryPerformanceFrequency（&feq）;//每秒跳动次数
QueryPerformanceCounter（&t1）;//测前跳动次数
node*p=front->next;
while（p->next）//排序查找无序边界
{
comparef++;
if（p->data>p->next->data）
turn（p,p->next）;
p=p->next;
}
node*pos=p;p=front->next;
while（pos!
=front->next）
{
node*bound=pos;
pos=front->next;
while（p->next!
=bound）
{
comparef++;
if（p->data>p->next->data）
{
turn（p,p->next）;pos=p->next;
}
p=p->next;
}
p=front->next;
}
QueryPerformanceCounter（&t2）;//测后跳动次数
doubled=（（double）t2、QuadPart-（double）t1、QuadPart）/（（double）feq、QuadPart）;//时间差秒
cout<<"操作时间为:
"<}
4、选择排序:
每趟排序再待排序的序列中选择关键码最小的元素,顺序添加至已排好的有序序列最后,知道全部记录排序完毕。
voidLinkList:
:
SelectSort（）
{
LARGE_INTEGERt1,t2,feq;
QueryPerformanceFrequency（&feq）;//每秒跳动次数
QueryPerformanceCounter（&t1）;//测前跳动次数
node*s=front;
while（s->next->next）
{
node*p=s;
node*index=p;
while（p->next）
{
comparef++;
if（p->next->datanext->data）
index=p;
p=p->next;
}
insert（index,s）;
s=s->next;
}
QueryPerformanceCounter（&t2）;//测后跳动次数
doubled=（（double）t2、QuadPart-（double）t1、QuadPart）/（（double）feq、QuadPart）;//时间差秒
cout<<"操作时间为:
"<}
5、堆排序:
利用前一趟比较的结果来减少比较次数,提高整体的效率。
其中通过链表储存了一棵树。
选择使用小根堆进行排序。
voidLinkList:
:
sift（intk,intm）
{
inti=k,j=2*i;
while（j<=m）
{
comparef++;
if（jdata>Get（j+1）->data））j++;
if（Get（i）->datadata）break;
else
{
turn（Get（i）,Get（j））;
i=j;
j=2*i;
}
}
}
voidLinkList:
:
heapsort（intn）
{
LARGE_INTEGERt1,t2,feq;
QueryPerformanceFrequency（&feq）;//每秒跳动次数
QueryPerformanceCounter（&t1）;//测前跳动次数
for（inti=n/2;i>=1;i--）
sift（i,n）;
for（inti=1;i{
turn（Get
（1）,Get（n-i+1））;
sift（1,n-i）;
}
QueryPerformanceCounter（&t2）;//测后跳动次数
doubled=（（double）t2、QuadPart-（double）t1、QuadPart）/（（double）feq、QuadPart）;//时间差秒
cout<<"操作时间为:
"<}
其中堆排序中需要知道孩子节点与父亲节点处的值,故设置了函数获取i出的指针。
node*LinkList:
:
Get（inti）
{
node*p=front->next;
intj=1;
while（j!
=i&&p）
{
p=p->next;
j++;
}
if（!
p）throw"查找位置非法";
elsereturnp;
};
6、输出结果的函数:
voidtell（LinkList&a,LinkList&b,LinkList&c,LinkList&d,LinkList&e）
{
a、print（）;
comparef=0;movef=0;
a、InsertSort（）;
cout<<"排序结果:
";a、print（）;
cout<<"1、插入排序法:
Compare:
"<"<
comparef=0;movef=0;
b、BubbleSort（）;
cout<<"2、改进型冒泡排序法:
Compare:
"<"<
comparef=0;movef=0;
c、QSort（）;
cout<<"3、快速排序法:
Compare:
"<"<comparef=0;movef=0;
d、SelectSort（）;
cout<<"4、简单选择排序法Compare:
"<"<comparef=0;movef=0;
e、heapsort（10）;
cout<<"5、堆排序算法Compare:
"<"<}
7、统计时间的函数:
#include
{
LARGE_INTEGERt1,t2,feq;
QueryPerformanceFrequency（&feq）;//每秒跳动次数
QueryPerformanceCounter（&t1）;//测前跳动次数
node*p=front->next;//要插入的节点的前驱
QueryPerformanceCounter（&t2）;//测后跳动次数
doubled=（（double）t2、QuadPart-（double）t1、QuadPart）/（（double）feq、QuadPart）;//时间差秒
cout<<"操作时间为:
"<};
2、3其她
算法的时间复杂度:
排序方法
随机序列的平均情况
最好情况
最坏情况
辅助空间
直接插入排序
O（n2）
O（n）
O（n2）
O
（1）
快速排序
O（nlog2n）
O（nlog2n）
O（n2）
O（log2n）~O（n）
改进版冒泡排序
O（n2）
O（n）
O（n2）
O
（1）
选择排序
O（n2）
O（n2）
O（n2）
O
（1）
堆排序
O（nlog2n）
O（nlog2n）
O（nlog2n）
O
（1）
3、程序运行结果
1、流程图
开始
:
初始化正序链表,调用各类排序,并输出运行结果
初始化逆序链表,调用各类排序,并输出运行结果
初始化顺序随机的链表,调用各类排序,并输出运行结果
结束
2、测试条件:
如果需要对不同的正序,逆序随机序列进行排序,则需要在main函数中进行初始化设置。
3、测试结论:
4、总结
通过这次实验我再次复习了链表的建立及相应的操作,对各类排序算法的实现也有了新的理解,在调试过程中出现了许多问题也花费了很多时间与精力去逐步解决,最后程序运行成功的瞬间真的很开心。
问题一:
直接插入排序中若就是使用从后向前比较插入的话（即书上的办法）难以找到该节点的前驱节点,不方便进行操作,所以最后采用了从前向后进行比较。
voidLinkList:
:
InsertSort（）//将第一个元素定为初始有序区元素,由第二个元素开始依次比较
{
LARGE_INTEGERt1,t2,feq;
QueryPerformanceFrequency（&feq）;//每秒跳动次数
QueryPerformanceCounter（&t1）;//测前跳动次数
node*p=front->next;//要插入的节点的前驱
while（p->next）
{
node*s=front;//充分利用带头结点的单链表
while
（1）
{
comparef++;
if（p->next->datanext->data）//[P后继]比[S后继]小则插入
{
insert（p,s）;break;
}
s=s->next;
if（s==p）//若一趟比较结束,且不需要插入
{
p=p->next;break;
}
}
}
问题二:
如何将书上以数组方式储存的树转化为链表储存并进行操作？
原本打算建立一颗完全二叉树储存相应数据再进行排序,但就是那样的话需要新设置结点存左孩子右孩子,比较麻烦容易出错,所以选择了利用Get（inti）函数将筛选结点的位置获得。
与书上代码相比修改如下:
if（jdata>Get（j+1）->data））j++;
if（Get（i）->datadata）break;
else
{
turn（Get（i）,Get（j））;
i=j;
j=2*i;
}
问题三:
时间如何精确至微秒？
需要调用函数,这个问题就是上网查找解决的。
总结:
解决了以上的问题后代码就比较完整了,可就是还就是希望通过日后的学习能将算法编写得更完善,灵活,简捷。
附录:
完整代码如下:
#include"lianbiaopaixu、h"
#include
usingnamespacestd;
voidmain（）
{
inta[10]={1,2,3,4,5,6,7,8,9,10};
LinkListzhengxu1（a,10）,zhengxu2（a,10）,zhengxu3（a,10）,zhengxu4（a,10）,zhengxu5（a,10）;
cout<<"正序数列:
";
tell（zhengxu1,zhengxu2,zhengxu3,zhengxu4,zhengxu5）;
intb[10]={10,9,8,7,6,5,4,3,2,1};
LinkListnixu1（b,10）,nixu2（b,10）,nixu3（b,10）,nixu4（b,10）,nixu5（b,10）;
cout<<"\n逆序数列:
";
tell（nixu1,nixu2,nixu3,nixu4,nixu5）;
intc[10]={2,6,10,5,8,3,9,1,4,7};
LinkListsuiji1（c,10）,suiji2（c,10）,suiji3（c,10）,suiji4（c,10）,suiji5（c,10）;
cout<<"\n随机数列:
";
tell（suiji1,suiji2,suiji3,suiji4,suiji5）;
}
#include
#include
#include
#include
#include
#include
usingnamespacestd;
intcomparef;
intmovef;
structnode
{
intdata;
node*next;
};
classLinkList
{
private:
node*front;
public:
LinkList（inta[],intn）;//构造
~LinkList（）;
voidinsert（node*p,node*s）;//插入
voidturn（node*p,node*s）;//交换数据
voidprint（）;//输出
voidInsertSort（）;//插入排序
voidBubbleSort（）;//pos冒泡
voidQSort（）;//快速排序
voidSelectSort（）;//简单选择排序
node*Get（inti）;//查找位置为i的结点
voidsift（intk,intm）;//一趟堆排序
voidLinkList:
:
QSZ（node*b,node*e）;//快速排序的递归主体
voidheapsort（intn）;//堆排序算法
};
LinkList:
:
LinkList（inta[],intn）
{
front=newnode;
front->next=NULL;
for（inti=n-1;i>=0;i--）
{
node*p=newnode;//新节点
p->data=a[i];
p->next=front->next;
front->next=p;//头插法建立单链表,最先加入的被不断后移
}
}
LinkList:
:
~LinkList（）
{
node*q=front;
while（q）
{
front=q;
q=q->next;
deletefront;
}
}
voidLinkList:
:
insert（node*p,node*s）//将p->next插入s与s->n
升级会员 