排序算法多种算法实现插入 堆 希尔 快排.docx
《排序算法多种算法实现插入 堆 希尔 快排.docx》由会员分享，可在线阅读，更多相关《排序算法多种算法实现插入 堆 希尔 快排.docx（16页珍藏版）》请在冰豆网上搜索。
排序算法多种算法实现插入堆希尔快排
#include
#include
#include
////实现简单选择排序、直接插入排序和冒泡排序
voidSelectSort（）
{
intm,t;
inta[]={8,2,4,3,6},n=5;
for（inti=0;i{
intmin=a[i];
for（intj=i+1;j{
if（min>a[j]）
{
min=a[j];
m=j;
}
}
if（a[i]!
=min）
{
t=a[i];
a[i]=a[m];
a[m]=t;
}
}
//打印
for（i=0;iprintf（"%d",a[i]）;
printf（"\n"）;
}
//实现简单的数组的插入排序/
voidinserssort（）
{
intx;
inta[]={2,3,4,6,8},n=5;
printf（"请输入要插入的数据\n"）;
scanf（"%d",&x）;
inttem=x;
for（inti=0;i{
if（x>a[i]&&xbreak;
}
for（intj=n-1;j>i;j--）
a[j+1]=a[j];
a[i+1]=tem;
for（i=0;iprintf（"%d",a[i]）;
printf（"\n"）;
}
//实现简单的数组的冒泡排序/
voidmaopao（）//冒泡
{
inta[]={8,2,4,3,6},n=5;
inti,j,temp;
for（i=1;ifor（j=0;j{
if（a[j]>a[j+1]）
{
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
for（i=0;iprintf（"%d",a[i]）;
printf（"\n"）;
}
////实现希尔排序算法
voidshellsort（）
{
inta[]={8,2,4,3,6},n=5;
inttemp,Gap;
inti,j;
printf（"希尔排序为:
\n"）;
Gap=n/2;
while（Gap>0）
{
for（i=Gap;i{
j=i-Gap;
while（j>=0）
if（a[j]>a[j+Gap]）
{
temp=a[j];
a[j]=a[j+Gap];
a[j+Gap]=temp;
j=j-Gap;
}
elsebreak;
}
Gap/=2;
}
for（i=0;iprintf（"%d",a[i]）;
printf（"\n"）;
}
/////////快速排序实现
intpartition（intn[],intleft,intright）;//partition函数的声明
intm=5;//（自定义简单的数组的长度）
voidSwap（int*i,int*j）
{
int*temp;
temp=i;
i=j;
j=temp;
}
voidquicksort（intn[],intleft,intright）
{
intdp;
if（left{
dp=partition（n,left,right）;
quicksort（n,left,dp-1）;
quicksort（n,dp+1,right）;//这两个就是递归调用，分别整理53左边的数组和右边的数组
}
}
intpartition（intn[],intleft,intright）
{
intlo,hi,pivot,t;
pivot=n[left];
lo=left-1;
hi=right+1;
while（lo+1!
=hi）{
if（n[lo+1]<=pivot）
lo++;
elseif（n[hi-1]>pivot）
hi--;
else{
t=n[lo+1];
n[++lo]=n[hi-1];
n[--hi]=t;
}
}
n[left]=n[lo];
n[lo]=pivot;
returnlo;
}
//////堆排序的简单数组实现
voidHeapAdjust（intarray[],inti,intnLength）
{
intnChild,nTemp;
for（nTemp=array[i];2*i+1{
//子结点的位置是父结点位置*2+1
nChild=2*i+1;//得到子结点中较大的结点
if（nChild!
=nLength-1&&array[nChild+1]>array[nChild]）
++nChild;//如果较大的子结点大于父结点那么把较大的子结点往上移动,替换它的父结点
if（nTemp{
array[i]=array[nChild];
}
else//否则退出循环
{
break;
}
}//最后把需要调整的元素值放到合适的位置
array[i]=nTemp;
}
//堆排序算法
voidHeapSort（intarray[],intlength）
{
//调整序列的前半部分元素,调整完之后第一个元素是序列的最大的元素
for（inti=length/2-1;i>=0;--i）
{
HeapAdjust（array,i,length）;
}
//从最后一个元素开始对序列进行调整,不断的缩小调整的范围直到第一个元素
for（i=length-1;i>0;--i）
{
//把第一个元素和当前的最后一个元素交换,
//保证当前的最后一个位置的元素都是在现在的这个序列之中最大的
Swap（&array[0],&array[i]）;//不断缩小调整heap的范围,每一次调整完毕保证第一个元素是当前序列的最大值
HeapAdjust（array,0,i）;
}
}
////输出数组
voidprint（intb[]）
{
for（inti=0;iprintf（"%d",b[i]）;
printf（"\n"）;
}
/////////////链式存储结构单链表的操作排序
//创建一个单链表，初始化数据
typedefstructlonde
{
intdata;
structlonde*next;
}londe,*linklist;
voidcreatelist（linklist&L）
{
linklistp=（linklist）malloc（sizeof（londe））;
p->data=NULL;
p->next=NULL;
L=p;
}
voidinsertlist（linklist&L）
{
linklistp;
intas;
p=L;
printf（"请输入链表的的元素，输入以#为结束\n"）;
while（scanf（"%d",&as）&&as!
='#'）
{
linklistq=（linklist）malloc（sizeof（londe））;
q->data=as;
q->next=NULL;
p->next=q;
p=q;
}
printf（"链表创建成功！
！
\n"）;
}/////////链表创建生成完成
voidprintlist（linklist&L）
{
linklistp;
p=L->next;
while（p）
{
printf（"%d",p->data）;
p=p->next;
}
printf（"\n"）;
}
/////链表的排序操作
intrtnlegth（linklist&L）//计算双向链表的长度
{
linklistp;
intcount=0;
p=L->next;
while（p）
{
count++;
p=p->next;
}
return（count）;
}
voidlistSelectSort（linklist&L）//链表的选择排序
{
linklistp,q,small;
inttemp;
for（p=L->next;p->next!
=NULL;p=p->next）
{
small=p;
for（q=p->next;q;q=q->next）
if（q->datadata）
small=q;
if（small!
=p）
{
temp=p->data;
p->data=small->data;
small->data=temp;
}
}
printf（"选择排序结果如下:
\n"）;
printlist（L）;
printf（"\n"）;
}
voidinsertlistsort（linklist&L）//链表的插入排序
{
linklistp;
intxx;
p=L->next;
printf（"请输入要插入的数据\n"）;
scanf（"%d",&xx）;
linklistpp=（linklist）malloc（sizeof（londe））;
pp->data=xx;
if（p->data>=xx）
{
pp->next=p;
L=p;
return;
}
while（p->next）
{
if（xx>=p->data&&p->next->data>=xx）
pp->next=p->next->next;
p->next=pp;
return;
}
printf（"插入排序结果如下:
\n"）;
printlist（L）;
printf（"\n"）;
}
voidmaopao（linklist&L）//链表的冒泡排序
{
linklistp;
inttem;
for（inti=1;i{
p=L->next;
for（intj=0;j{
if（p->data>=p->next->data）
{
tem=p->data;
p->data=p->next->data;
p->next->data=tem;
}
p=p->next;
}
}
printf（"冒泡排序结果如下:
\n"）;
printlist（L）;
printf（"\n"）;
}
intmain（）
{
intmm,nn;
intb[]={8,2,4,3,6};
linklistL;
printf（"请选择菜单：
******************************\n"）;
printf（"1:
实现简单选择排序、直接插入排序和冒泡排序\n"）;
printf（"2:
实现希尔排序算法************************\n"）;
printf（"3:
实现快速排序算法************************\n"）;
printf（"4:
实现堆排序算法**************************\n"）;
printf（"采用链式存储实现简单选择排序、直接插入排序和冒泡排序\n"）;
printf（"5:
创建一个链表输出并:
**********************\n"）;
printf（"6:
链表选择排序:
****************************\n"）;
printf（"7:
链表插入排序:
****************************\n"）;
printf（"8:
链表冒泡排序:
*****************************\n"）;
printf（"\n"）;
while（scanf（"%d",&mm）!
=EOF）
{
switch（mm）
{
case1:
{
printf（"1:
选择排序\n"）;
printf（"2:
插入排序\n"）;
printf（"3:
冒泡排序\n"）;
while（scanf（"%d",&nn）!
=EOF）
{
switch（nn）
{
case1:
SelectSort（）;
break;
case2:
inserssort（）;
break;
case3:
maopao（）;
break;
}
break;
}
printf（"\n"）;
break;
}
case2:
shellsort（）;
printf（"\n"）;
break;
case3:
quicksort（b,0,4）;
printf（"快速排序为\n"）;
print（b）;
break;
case4:
printf（"堆排序为\n"）;
HeapAdjust（b,1,5）;
print（b）;
break;
case5:
createlist（L）;
insertlist（L）;
break;
case6:
listSelectSort（L）;
break;
case7:
insertlistsort（L）;
break;
case8:
maopao（L）;
break;
}
printf（"\n"）;
printf（"1:
实现简单选择排序、直接插入排序和冒泡排序\n"）;
printf（"2:
实现希尔排序算法************************\n"）;
printf（"3:
实现快速排序算法************************\n"）;
printf（"4:
实现堆排序算法**************************\n"）;
printf（"采用链式存储实现简单选择排序、直接插入排序和冒泡排序\n"）;
printf（"5:
创建一个链表输出并:
**********************\n"）;
printf（"6:
链表选择排序:
****************************\n"）;
printf（"7:
链表插入排序:
****************************\n"）;
printf（"8:
链表冒泡排序:
*****************************\n"）;
printf（"\n"）;
}
return0;
}
升级会员 