数据结构之排序总结C语言.docx

数据结构之排序总结C语言.docx

《数据结构之排序总结C语言.docx》由会员分享，可在线阅读，更多相关《数据结构之排序总结C语言.docx（15页珍藏版）》请在冰豆网上搜索。

数据结构之排序总结C语言

//数据结构实验课程之手工执行一下排序算法，

//写出每一趟排序结束时的关键码状态

#include

#include

#definemaxsize20

//结构体的定义

typedefstruct

{

intL[maxsize+1];

intlength;

}list;

//以下是八种排序方法的子函数的说明

voiddisplay（listm）;//输出函数

voidmenu（listm）;//菜单函数

voidstraight（listm）;//直接插入排序

voidshell（listm）;//希尔排序（增量d[1]=5）

voidbubble（listm）;//起泡排序

voidquick（listm）;//快速排序

voidselection（listm）;//简单选择排序

voidheap（listm）;//堆排序

voidmerg（listm）;//归并排序

voidradix（listm）;//基数排序

voidshellinsert（list*m,intnum）;

voidqsort（list*m,intlow,inthigh）;

intpartition（list*m,intlow,inthigh）;

intselectmin（list*m,intnum）;

voidheapadjust（list*m,ints,intn）;

voidmsort（intsr[],inttr1[],ints,intt）;

voidmer（intsr[],inttr[],inti,intm,intt）;

//主函数

voidmain（）

{

lista;

inti;

charch;

printf（"Firstly,let'screatethelist.\n"）;

printf（"pleaseinputthelengthofthelist:

\n"）;

scanf（"%d",&a.length）;

printf（"pleaseinputthekeywordofthelist:

\n"）;

for（i=1;i<=a.length;i++）

{

scanf（"%d",&a.L[i]）;

}

display（a）;

getchar（）;

printf（"\nLet'sgotothemenu\n"）;

getchar（）;

system（"cls"）;

do

{

menu（a）;

printf（"\nDoyouwanttocontinue?

（Y/N）\n"）;

fflush（stdin）;

scanf（"%c",&ch）;

getchar（）;

system（"cls"）;

}while（ch=='y'||ch=='Y'）;

}

voiddisplay（listm）

{

inti;

printf（"\nThelistisfollowing:

\n"）;

for（i=1;i<=m.length;i++）

{

printf（"--%d--",m.L[i]）;

}

}

//菜单界面

voidmenu（listm）

{

intnumber;

printf（"|*^*^*^*^*^*^*^*^*^*^*^*^*MENU*^*^*^*^*^*^*^*^*^*^*^*^*|\n"）;

printf（"|^o^o^o^o^1.StraightInsertionSort^o^o^o^o^|\n"）;

printf（"|^o^o^o^o^2.Shell'sSort^o^o^o^o^|\n"）;

printf（"|^o^o^o^o^3.BubbleSort^o^o^o^o^|\n"）;

printf（"|^o^o^o^o^4.QuickSort^o^o^o^o^|\n"）;

printf（"|^o^o^o^o^5.SimpleSelectionSort^o^o^o^o^|\n"）;

printf（"|^o^o^o^o^6.HeapSort^o^o^o^o^|\n"）;

printf（"|^o^o^o^o^7.MergingSort^o^o^o^o^|\n"）;

printf（"|^o^o^o^o^8.RadixSort^o^o^o^o^|\n"）;

printf（"Pleaseinputyourchoice:

\n"）;

scanf（"%d",&number）;

switch（number）

{

case1:

straight（m）;break;

case2:

shell（m）;break;

case3:

bubble（m）;break;

case4:

quick（m）;break;

case5:

selection（m）;break;

case6:

heap（m）;break;

case7:

merg（m）;break;

case8:

radix（m）;break;

default:

printf（"Yourchoiceiswrong!

\n"）;

}

}

voidstraight（listm）

{

inti,j,num=1;

display（m）;

for（i=2;i<=m.length;i++）

{

if（m.L[i]

{

m.L[0]=m.L[i];

m.L[i]=m.L[i-1];

for（j=i-2;m.L[0]

{

m.L[j+1]=m.L[j];

}

m.L[j+1]=m.L[0];

}

getchar（）;

printf（"\n^o^o^o^o^（%d）^o^o^o^o^",num++）;

display（m）;

}

}

voidshell（listm）

{

intdlta[3]={5,3,1};

inti,num=1;

display（m）;

for（i=0;i<3;i++）

{

shellinsert（&m,dlta[i]）;

getchar（）;

printf（"\n^o^o^o^o^（%d）^o^o^o^o^",num++）;

display（m）;

}

}

voidshellinsert（list*m,intnum）

{

inti,j;

for（i=num+1;i<=m->length;i++）

{

if（m->L[i]L[i-num]）

{

m->L[0]=m->L[i];

for（j=i-num;j>0&&（（m->L[0]）<（m->L[j]））;j-=num）

{

m->L[j+num]=m->L[j];

}

m->L[j+num]=m->L[0];

}

}

}

voidbubble（listm）

{

inti,j,t,num=1;

display（m）;

for（i=1;i

{

for（j=1;j<=m.length-i;j++）

{

if（m.L[j]>m.L[j+1]）

{

t=m.L[j];

m.L[j]=m.L[j+1];

m.L[j+1]=t;

}

}

getchar（）;

printf（"\n^o^o^o^o^（%d）^o^o^o^o^",num++）;

display（m）;

}

}

voidquick（listm）

{

qsort（&m,1,m.length）;

display（m）;

}

voidqsort（list*m,intlow,inthigh）//递归算法

{

intpivotloc;

if（low

{

pivotloc=partition（m,low,high）;

qsort（m,low,pivotloc-1）;

qsort（m,pivotloc+1,high）;

}

}

intpartition（list*m,intlow,inthigh）//将比枢轴大的数移到枢轴右侧，小的移到左侧

{

intnum;

num=m->L[low];

m->L[0]=m->L[low];

while（low

{

while（lowL[high]>=num）

{

--high;

}

m->L[low]=m->L[high];

while（lowL[low]<=num）

{

++low;

}

m->L[high]=m->L[low];

}

m->L[low]=m->L[0];

returnlow;

}

voidselection（listm）

{

inti,j,num,a=1;

display（m）;

for（i=1;i

{

j=selectmin（&m,i）;

if（j!

=i）

{

num=m.L[i];

m.L[i]=m.L[j];

m.L[j]=num;

}

getchar（）;

printf（"\n^o^o^o^o^（%d）^o^o^o^o^",a++）;

display（m）;

}

}

intselectmin（list*m,intnum）

{

inti,j,min;

j=num;

min=m->L[num];

for（i=num;i<=m->length;i++）

{

if（min>m->L[i]）

{

min=m->L[i];

j=i;

}

}

returnj;

}

voidheap（listm）

{

inti,j,t,num=1;

j=m.length;

display（m）;

for（i=m.length/2;i>0;i--）//建成大顶堆

{

heapadjust（&m,i,m.length）;

}

display（m）;

for（i=m.length;i>0;i--）

{

t=m.L[1];

m.L[1]=m.L[i];

m.L[i]=t;

heapadjust（&m,1,--j）;

getchar（）;

printf（"\n^o^o^o^o^（%d）^o^o^o^o^",num++）;

display（m）;

//因为该无序表已经建成了大顶堆，故将L[1[与L[i]交换后，2到i-1依旧符合堆的定义

}//所以只需要一次筛选就行了。

}

voidheapadjust（list*m,ints,intn）

{

inti,num;

for（i=2*s;i<=n;i*=2）

{

if（iL[i]L[i+1]））//注意：

i

完全二叉树有一个

{//性质就是，如果节点数为奇数则没有孩子会成对出现，如果为偶数，则会单个出现。

i++;

}

if（m->L[i]<=m->L[s]）break;

num=m->L[s];

m->L[s]=m->L[i];

m->L[i]=num;

s=i;//s=s*2;例如对2-n筛选时，当结点2与其左右孩子比较完了之后，

}

//还需要结点4与其左右孩子比较

}

voidmerg（listm）

{listn;

n=m;

display（m）;

msort（m.L,n.L,1,m.length）;

printf（"\nTheresultis:

\n"）;

display（n）;//数组名作为形参传递给子函数时，是使用的地址传递，listn是经过重新排序的表。

}

voidmsort（intsr[],inttr1[],ints,intt）//运用了一个递归函数，将顺序表逐渐分割成子表

{

intnum;

inttr2[maxsize]={0};

if（s==t）

{

tr1[s]=sr[s];

}

else

{

num=（s+t）/2;

msort（sr,tr2,s,num）;

msort（sr,tr2,num+1,t）;

mer（tr2,tr1,s,num,t）;

}

}

voidmer（intsr[],inttr[],inti,intm,intt）//对子表进行排序的函数，新生成的表的数组为tr[]

{

intj,k;

for（j=m+1,k=i;i<=m&&j<=t;k++）

{

if（sr[i]

{

tr[k]=sr[i];

i++;

}

else

{

tr[k]=sr[j];

j++;

}

}

while（i<=m）

{

tr[k++]=sr[i++];

}

while（j<=t）

{

tr[k++]=sr[j++];

}

}

voidradix（listm）

{

inti,j,t;

display（m）;

for（i=1;i

{

for（j=1;j

{

if（（m.L[j]/100）>（m.L[j+1]/100））

{

t=m.L[j];

m.L[j]=m.L[j+1];

m.L[j+1]=t;

}

}

}

getchar（）;

printf（"\n^o^o^o^o^

（1）^o^o^o^o^"）;

display（m）;

for（i=1;i

{

for（j=1;j

{

if（（m.L[j]/100）==（m.L[j+1]/100））

{

if（（（m.L[j]/10）%10）>（（m.L[j+1]/10）%10））

{

t=m.L[j];

m.L[j]=m.L[j+1];

m.L[j+1]=t;

}

}

}

}

printf（"\n^o^o^o^o^

（2）^o^o^o^o^"）;

display（m）;

for（i=1;i

{

for（j=1;j

{

if（（（m.L[j]/100）==（m.L[j+1]/100））&&（（（m.L[j]/10）%10）>（（m.L[j+1]/10）%10）））

{

if（（m.L[j]-（（m.L[j]/100）*100））%10>（m.L[j]-（（m.L[j+1]/100）*100））%10）

{

t=m.L[j];

m.L[j]=m.L[j+1];

m.L[j+1]=t;

}

}

}

}

printf（"\n^o^o^o^o^（3）^o^o^o^o^"）;

display（m）;

}