数据结构实验报告四实现典型的排序算法Word下载.docx
- 文档编号:22262603
- 上传时间:2023-02-03
- 格式:DOCX
- 页数:16
- 大小:68.67KB
数据结构实验报告四实现典型的排序算法Word下载.docx
《数据结构实验报告四实现典型的排序算法Word下载.docx》由会员分享,可在线阅读,更多相关《数据结构实验报告四实现典型的排序算法Word下载.docx(16页珍藏版)》请在冰豆网上搜索。
//关键字
intdata;
//其他数据项
intnext;
}SLCell;
SLCellr[MAX_SPACE];
//静态链表可利用空间
intkeynum;
//记录的当前关键字个数
intrecnum;
//静态链表的当前长度
}SLList;
typedefintArrType[RADIX];
//指针数组类型
intlen;
//数组长度
//插入排序
voidDirectInsertSort(intElem_Arr[])
inti,j;
for(i=2;
i<
len;
i++)
{
Elem_Arr[0]=Elem_Arr[i];
for(j=i-1;
j>
=1;
j--)
if(Elem_Arr[0]<
Elem_Arr[j])
Elem_Arr[j+1]=Elem_Arr[j];
else
break;
Elem_Arr[j+1]=Elem_Arr[0];
}
}
//希尔排序
voidShellInsert(intElem_Arr[],intadd)//add为某趟希尔排序的增量
for(i=add+1;
for(j=i-add;
0&
&
Elem_Arr[j]>
Elem_Arr[0];
j-=add)
Elem_Arr[j+add]=Elem_Arr[j];
Elem_Arr[j+add]=Elem_Arr[0];
voidShellSort(intElem_Arr[])
intt;
cout<
<
"
请输入增量数组元素个数:
endl;
cin>
>
t;
int*dlta=newint[t];
请依次输入增量数组元素:
for(inti=0;
cin>
dlta[i];
for(intk=0;
k<
++k)
ShellInsert(Elem_Arr,dlta[k]);
//一趟增量为dlta[k]的插入排序
//快速排序
intPartition(intElem_Arr[],inti,intj)//实现一分为二,pivotkey为枢轴变量
intpivotkey;
pivotkey=Elem_Arr[i];
while(i<
j)
{
while(i<
j&
=pivotkey)
--j;
Elem_Arr[i]=Elem_Arr[j];
Elem_Arr[i]<
++i;
Elem_Arr[j]=Elem_Arr[i];
Elem_Arr[i]=pivotkey;
returni;
}//Partition
voidQSort(intElem_Arr[],intlow,inthigh)
intpivotloc;
if(low<
high)
pivotloc=Partition(Elem_Arr,low,high);
QSort(Elem_Arr,low,pivotloc-1);
QSort(Elem_Arr,pivotloc+1,high);
voidQuickSort(intElem_Arr[])
QSort(Elem_Arr,1,len-1);
//简单选择排序
intSelectMin(intElem_Arr[],inti)
intmin=i;
for(intj=i+1;
j<
j++)
if(Elem_Arr[min]>
min=j;
returnmin;
voidSelectSort(intElem_Arr[])
intt,j;
for(inti=1;
++i)
j=SelectMin(Elem_Arr,i);
if(i!
=j)
{
t=Elem_Arr[i];
Elem_Arr[i]=Elem_Arr[j];
Elem_Arr[j]=t;
}
}//SelectSort
//堆排序
voidHeapAdjust(intElem_Arr[],inti,intm)
Elem_Arr[0]=Elem_Arr[i];
for(intj=2*i;
=m;
j*=2)
if(j<
m&
Elem_Arr[j]<
Elem_Arr[j+1])
++j;
if(Elem_Arr[0]>
Elem_Arr[j])
break;
i=j;
Elem_Arr[i]=Elem_Arr[0];
voidHeapSort(intElem_Arr[])
for(inti=(len-1)/2;
i>
0;
--i)
HeapAdjust(Elem_Arr,i,len-1);
for(i=len-1;
1;
Elem_Arr[i]=Elem_Arr[1];
Elem_Arr[1]=Elem_Arr[0];
HeapAdjust(Elem_Arr,1,i-1);
//归并排序
voidMerge(intElem_Arr1[],intElem_Arr[],inti,intm,intn)//将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n]
intj,k;
for(j=m+1,k=i;
=m&
=n;
++k)
//将SR中记录由小到大地并入TR
if(Elem_Arr1[i]<
Elem_Arr1[j])
Elem_Arr[k]=Elem_Arr1[i++];
else
Elem_Arr[k]=Elem_Arr1[j++];
if(i<
=m)//TR[k..n]=SR[i..m];
将剩余的SR[i..m]复制到TR
while(k<
=n&
=m)
Elem_Arr[k++]=Elem_Arr1[i++];
=n)//将剩余的SR[j..n]复制到TR
while(k<
=n)
Elem_Arr[k++]=Elem_Arr1[j++];
}
voidMSort(intElem_Arr1[],intElem_Arr[],ints,intt)//将SR[s..t]归并排序为TR1[s..t]
intm;
intTR2[20];
if(s==t)
Elem_Arr[t]=Elem_Arr1[s];
else
m=(s+t)/2;
//将SR[s..t]平分为SR[s..m]和SR[m+1..t]
MSort(Elem_Arr1,TR2,s,m);
//递归地将SR[s..m]归并为有序的TR2[s..m]
MSort(Elem_Arr1,TR2,m+1,t);
//将SR[m+1..t]归并为有序的TR2[m+1..t]
Merge(TR2,Elem_Arr,s,m,t);
//将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t]
voidMergeSort(intElem_Arr[])//对顺序表L作归并排序。
int*Elem_Arr1=newint[len];
Elem_Arr1[i]=Elem_Arr[i];
MSort(Elem_Arr1,Elem_Arr,1,len-1);
//基数排序
intsucc(intf[],intj)
intk=j;
for(j;
10;
if(f[j]!
=0)break;
elsek++;
if(j<
10)returnk;
elsereturn0;
voidCreateL(SLList&
L)
{
请依次输入元素:
=L.recnum;
L.r[i].data;
L.r[i].keys[0]=L.r[i].data%10;
L.r[i].keys[1]=(L.r[i].data%100-L.r[i].keys[0])/10;
L.r[i].keys[2]=L.r[i].data/100;
voidDistribute(SLList&
L,inti,ArrType&
f,ArrType&
e)
//算法10.15
//静态链表L的r域中记录已按(keys[0],...,keys[i-1])有序,
//本算法按第i个关键字keys[i]建立RADIX个子表,
//使同一子表中记录的keys[i]相同。
f[0..RADIX-1]和e[0..RADIX-1]
//分别指向各子表中第一个和最后一个记录。
intj,p;
for(j=0;
RADIX;
++j)
f[j]=0;
e[j]=0;
}//各子表初始化为空表
for(p=L.r[0].next;
p!
=0;
p=L.r[p].next)
j=L.r[p].keys[i];
//将记录中第i个关键字映射到[0..RADIX-1],
if(f[j]==0)
f[j]=p;
L.r[e[j]].next=p;
e[j]=p;
//将p所指的结点插入第j个子表中
}//Distribute
voidPrint_SLList(SLListL,inti)
for(intp=L.r[0].next;
p=L.r[p].next)
cout<
L.r[p].data<
"
;
voidCollect(SLList&
L,ArrTypef,ArrTypee)
//本算法按keys[i]自小至大地将f[0..RADIX-1]所指各子表依次链接成
//一个链表,e[0..RADIX-1]为各子表的尾指针
intt,j=0;
j=succ(f,j);
L.r[0].next=f[j];
//L.r[0].next指向第一个非空子表中第一个结点
t=e[j];
j++;
while(j!
=0&
f[j]!
=0)
{//找下一个非空子表//链接两个非空子表
L.r[t].next=f[j];
if(succ(f,j)==0)
break;
L.r[t].next=0;
//t指向最后一个非空子表中的最后一个结点
voidRadixSort(SLList&
L)
//L是采用静态链表表示的顺序表。
对L作基数排序,使得L成为按关键字自小到大的有序静态链表,L.r[0]为头结点。
inti;
ArrTypef,e;
L.keynum=3;
请输入所需排序元素个数(当前记录关键字个数<
=3):
L.recnum;
CreateL(L);
for(i=1;
++i)
L.r[i-1].next=i;
L.r[L.recnum].next=0;
//将L改造为静态链表
for(i=0;
L.keynum;
++i)//按最低位优先依次对各关键字进行分配和收集
Distribute(L,i,f,e);
//第i趟分配
Collect(L,f,e);
//第i趟收集
}
基数排序结果为:
Print_SLList(L,i);
voidCreatElem_Arr(intElem_Arr[])
Elem_Arr[i];
voidShowElem_Arr(intElem_Arr[])
voidoperate(intElem_Arr[])
inta,b,c;
直接排序请输入数字1"
希尔排序请输入数字2"
快速排序请输入数字3"
——————————————————"
a;
if(a==1)
intNO;
请输入需要排序元素个数:
NO;
len=NO+1;
Elem_Arr=newint[len];
CreatElem_Arr(Elem_Arr);
DirectInsertSort(Elem_Arr);
直接排序结果为:
ShowElem_Arr(Elem_Arr);
elseif(a==2)
ShellSort(Elem_Arr);
希尔排序结果为:
elseif(a==3)
QuickSort(Elem_Arr);
快速排序结果为:
elseif(a==4)
SelectSort(Elem_Arr);
简单选择排序结果为:
elseif(a==5)
HeapSort(Elem_Arr);
堆排序结果为:
elseif(a==6)
MergeSort(Elem_Arr);
归并排序结果为:
elseif(a==7)
SLListL;
RadixSort(L);
elsecout<
输入错误!
————————————————————————————————————————"
操作完毕,请输入“1”返回主菜单,否则请按其他任意键退出!
c;
if(c==1)
operate(Elem_Arr);
voidmain()
int*Elem_Arr;
operate(Elem_Arr);
程序结果截图:
六、实验结果分析及实验体会
通过这次数据结构我感觉自己收获还是挺多的,这次实验课做的课题是实现典型的排序算法,我最大的收获是感受到了计算机的真正运行原理,用这些代码来代替人为地工作,很久以前我觉得这是不可思议的事情,但是我今天竟然也做到了。
这次数据结构实验课,激发了我对学习的积极性,从程序编写,整理资料到完整运行,最后做调试的过程中,感觉到自己所学习的专业课也并不是那么枯燥乏味,并且明白了之前学不太好的原因,这门课确实需要以后不断的思考和实践,才可以逐渐提高自己专业课汲取知识的能力。
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 数据结构 实验 报告 实现 典型 排序 算法