排序算法(C语言实现)

冒泡排序

voidBubbleSort(ElementArray[],ArraySizeCount)//一趟后,把最小的数放到最前面
...{
ArraySizei,j;
Elementtemp;
for(i=0;i<Count-1;i++)
for(j=Count-1;j>i;j--)//从后往前找最小的数
if(Array[j]<Array[j-1])
...{
temp=Array[j];
Array[j]=Array[j-1];
Array[j-1]=temp;
}
}

voidBubbleSort2(ElementArray[],ArraySizeCount)//Improveperformance
...{
ArraySizei,j;
Elementtemp;
intflag;
for(i=0;i<Count-1;i++)
...{
flag=0;
for(j=Count-1;j>i;j--)
if(Array[j]<Array[j-1])
...{
temp=Array[j];
Array[j]=Array[j-1];
Array[j-1]=temp;
flag=1;
}
if(flag==0)break;
}
}

插入排序

voidInsertSort(Elementd[],ArraySizen)
...{
ArraySizei,j;
Elementt;
for(i=1;i<n;i++)
...{
t=d[i];
if(d[i]<d[i-1])
...{
for(j=i-1;j>=0&&t<d[j];j--)
d[j+1]=d[j];
d[j+1]=t;
}
}
}

快速排序

voidQuickSort(ElementArray[],ArraySizeCount)
...{
QuickSortRange(Array,0,Count-1);
}

ArraySizePartition(ElementArray[],ArraySizeLow,ArraySizeHigh)
...{
Elementv,temp;
ArraySizevPos;
vPos=Low;
v=Array[vPos];
Low++;

while(1)
...{
while((High>Low)&&(Array[High]>v))High--;
while((Low<High)&&(Array[Low]<=v))Low++;
if(Low>=High)break;
temp=Array[Low];
Array[Low]=Array[High];
Array[High]=temp;
Low++;
High--;
}
if(Array[Low]>v)Low--;
if(vPos!=Low)
...{
temp=Array[Low];
Array[Low]=Array[vPos];
Array[vPos]=temp;
}
returnLow;
}

voidQuickSortRange(ElementArray[],ArraySizeLow,ArraySizeHigh)
...{
ArraySizeMiddle;
if(Low<High)
...{
Middle=Partition(Array,Low,High);
QuickSortRange(Array,Low,Middle-1);
QuickSortRange(Array,Middle+1,High);
}
}

选择排序

voidSelectSort(Elementd[],ArraySizen)
...{
inti,j,k,t;

for(i=0;i<n-1;i++)
...{
k=i;
for(j=i+1;j<n;j++)
...{
if(d[j]<d[k])
k=j;
}
if(k!=i)
...{
t=d[i];
d[i]=d[k];
d[k]=t;
}
}
}

堆排序

voidBuildStock(ElementArray[],ArraySizeCount)
...{
longNum=Count/2,temp,i;

if(2*Num==Count)
...{
if(Array[Num-1]<Array[Count-1])
...{
temp=Array[Num-1];
Array[Num-1]=Array[Count-1];
Array[Count-1]=temp;
}
}
else
...{
if(Array[Num-1]<Array[Count-2]||Array[Num-1]<Array[Count-1])
...{
if(Array[Count-2]>Array[Count-1])
...{
temp=Array[Count-2];
Array[Count-2]=Array[Num-1];
Array[Num-1]=temp;
}
else
...{
temp=Array[Count-1];
Array[Count-1]=Array[Num-1];
Array[Num-1]=temp;
}
}
}


for(i=Num-1;i>0;i--)
...{
if(Array[i-1]<Array[i*2-1]||Array[i-1]<Array[i*2])
...{
if(Array[i*2-1]>Array[i*2])
...{
temp=Array[i*2-1];
Array[i*2-1]=Array[i-1];
Array[i-1]=temp;
SubStockSort(Array,i*2,Count);
}
else
...{
temp=Array[i*2];
Array[i*2]=Array[i-1];
Array[i-1]=temp;
SubStockSort(Array,i*2+1,Count);
}
}
}
}

voidSubStockSort(ElementArray[],ArraySizei,ArraySizeCount)
...{
longtemp;
if(2*i<Count)
...{
if(Array[i-1]<((Array[i*2-1]>Array[i*2])?Array[i*2-1]:Array[i*2]))
if(Array[i*2-1]>Array[i*2])
...{
temp=Array[i*2-1];
Array[2*i-1]=Array[i-1];
Array[i-1]=temp;
SubStockSort(Array,2*i,Count);
}
else
...{
temp=Array[i*2];
Array[2*i]=Array[i-1];
Array[i-1]=temp;
SubStockSort(Array,2*i+1,Count);
}
}
elseif(2*i==Count&&Array[i-1]<Array[2*i-1])
...{
temp=Array[i*2-1];
Array[2*i-1]=Array[i-1];
Array[i-1]=temp;
SubStockSort(Array,2*i,Count);
}
}

voidStockSort(ElementArray[],ArraySizeCount)
...{
longi,temp;

BuildStock(Array,Count);
temp=Array[Count-1];
Array[Count-1]=Array[0];
Array[0]=temp;

for(i=Count-1;i>1;i--)
...{
SubStockSort(Array,1,i);
temp=Array[i-1];
Array[i-1]=Array[0];
Array[0]=temp;
}
}

希尔排序

voidShellSort(Elementd[],ArraySizen)
...{

int*dt,k,i,t,dk,j;
k=n;
dt=(int*)malloc(sizeof(int)*(n/2));
i=0;
do
...{
k=k/2;
dt[i++]=k;
}while(k>0);
i=0;
while(dk=dt[i]>0)
...{
for(k=dt[i];k<n;++k)
...{
if(d[k]<d[k-dk])
...{
t=d[k];
for(j=k-dk;j>=0&&t<d[j];j-=dk)
d[j+dk]=d[j];
d[j+dk]=t;
}
}
++i;
}
}

基数排序

#defineBASE2_RADIX2
#defineDigitAtPos2(Number,Index)((Number&(1<<Index))>>Index)

#defineBASE8_RADIX8
#defineDigitAtPos8(Number,Index)((Number&(7<<(3*Index)))>>(3*Index))


//以2为基
voidRadixSort2(ElementArray[],ArraySizeCount)
...{
Element*pArrayList[BASE2_RADIX];
ArraySizeArrayListIndex[BASE2_RADIX];
ArraySizei,j;
intiList,jList;
intiLoop,LoopMax;

for(iList=0;iList<BASE2_RADIX;iList++)
...{
pArrayList[iList]=(Element*)malloc(Count*sizeof(Element));
if(pArrayList[iList]==NULL)
...{
printf("RadixSort分配内存出错! ");
for(jList=0;jList<iList;jList++)
free(pArrayList[jList]);
return;
}
}

LoopMax=(int)(log(Count)/log(BASE2_RADIX))+1;

for(iLoop=0;iLoop<LoopMax;iLoop++)
...{
for(i=0;i<BASE2_RADIX;i++)
ArrayListIndex[i]=0;

//Distribute
for(i=0;i<Count;i++)
...{
iList=DigitAtPos2(Array[i],iLoop);
pArrayList[iList][ArrayListIndex[iList]++]=Array[i];
}
//Collect
j=0;
for(iList=0;iList<BASE2_RADIX;iList++)
for(i=0;i<ArrayListIndex[iList];i++)
Array[j++]=pArrayList[iList][i];
}

for(i=0;i<BASE2_RADIX;i++)
free(pArrayList[i]);
}

//以8为基
voidRadixSort8(ElementArray[],ArraySizeCount)
...{
Element*pArrayList[BASE8_RADIX];
ArraySizeArrayListIndex[BASE8_RADIX];
ArraySizei,j;
intiList,jList;
intiLoop,LoopMax;

for(iList=0;iList<BASE8_RADIX;iList++)
...{
pArrayList[iList]=(Element*)malloc(Count*sizeof(Element));
if(pArrayList[iList]==NULL)
...{
printf("RadixSort分配内存出错! ");
for(jList=0;jList<iList;jList++)
free(pArrayList[jList]);
return;
}
}

LoopMax=(int)(log(Count)/log(BASE8_RADIX))+1;

for(iLoop=0;iLoop<LoopMax;iLoop++)
...{
for(i=0;i<BASE8_RADIX;i++)
ArrayListIndex[i]=0;

//Distribute
for(i=0;i<Count;i++)
...{
iList=DigitAtPos8(Array[i],iLoop);
pArrayList[iList][ArrayListIndex[iList]++]=Array[i];
}
//Collect
j=0;
for(iList=0;iList<BASE8_RADIX;iList++)
for(i=0;i<ArrayListIndex[iList];i++)
Array[j++]=pArrayList[iList][i];
}

for(i=0;i<BASE8_RADIX;i++)
free(pArrayList[i]);
}

归并排序

voidMerge(ElementArray[],ArraySizes,ArraySizem,ArraySizen)
...{
//将分别有序的Array[s...m]和Array[m+1...n]归并为有序的Array[s...n]
longi,j,k,b_s=s;
Element*temp;
temp=(Element*)malloc((n-s+1)*sizeof(Element));
for(i=m+1,k=0;s<=m&&i<=n;k++)
...{
if(Array[s]<Array[i])
...{
temp[k]=Array[s];
s++;
}
else
...{
temp[k]=Array[i];
i++;
}
}

for(j=s;j<=m;j++,k++)
temp[k]=Array[j];
for(j=i;j<=n;j++,k++)
temp[k]=Array[j];

for(i=b_s,j=0;i<=n;i++,j++)
Array[i]=temp[j];

if(temp)
free(temp);
}

voidMergeSort(ElementArray[],ArraySizeCount)
...{
longt=1,s,i;
longc=Count-1;
while(t<Count)
...{
s=t;
t=2*s;
i=0;
while(i+t<=Count)
...{
Merge(Array,i,i+s-1,i+t-1);
i=i+t;
}
if(i+s<Count)
Merge(Array,i,i+s-1,c);
}
}

Flash排序

constintTHRESHOLD=75;
constCLASS_SIZE=75;/**//*minimumvalueform*/

voidFlash(Elementa[],ArraySizen,intm,int*ctr)
...{

/**//*declarevariables*/

int*l,nmin,nmax,i,j,nmove,nx;

longc1,c2,flash,hold,k;

/**//*allocatespaceforthelvector*/

l=(int*)calloc(m,sizeof(int));

/**//*****CLASSFORMATION****/

nmin=nmax=0;

for(i=0;i<n;i++)

if(a[i]<a[nmin])nmin=i;

elseif(a[i]>a[nmax])nmax=i;

if((a[nmax]==a[nmin])&&(ctr==0))

...{

printf("Allthenumbersareidentical,thelistissorted ");

return;

}

c1=(long)(m-1.0)/(a[nmax]-a[nmin]);

c2=a[nmin];

l[0]=-1;/**//*sincethebaseofthe"a"(data)arrayis0*/

for(k=1;k<m;k++)l[k]=0;

for(i=0;i<n;i++)

...{

k=(long)floor(c1*(a[i]-c2));//下整

l[k]+=1;

}

for(k=1;k<m;k++)l[k]+=l[k-1];


hold=a[nmax];

a[nmax]=a[0];

a[0]=hold;

/**//****PERMUTATION*****/
nmove=0;

j=0;

k=m-1;

while(nmove<n)

...{

while(j>l[k])

...{

j++;

k=(long)floor(c1*(a[j]-c2));

}

flash=a[j];
while(j<=l[k])

...{

k=(long)floor(c1*(flash-c2));

hold=a[l[k]];

a[l[k]]=flash;

l[k]--;

flash=hold;

nmove++;

}

}

/**//****ChoiceofRECURSIONorSTRAIGHTINSERTION*****/
for(k=0;k<(m-1);k++)

if((nx=l[k+1]-l[k])>THRESHOLD)/**//*thenuserecursion*/

...{

Flash(&a[l[k]+1],nx,CLASS_SIZE,ctr);

(*ctr)++;

}

else/**//*useinsertionsort*/

for(i=l[k+1]-1;i>l[k];i--)

if(a[i]>a[i+1])

...{

hold=a[i];

j=i;

while(hold>a[j+1])a[j++]=a[j+1];

a[j]=hold;

}

free(l);/**//*needtofreethememorywegrabbedforthelvector*/
}

voidFlashSort(Elementd[],ArraySizen)
...{
intm=n,ctr;
Flash(d,n,m,&ctr);
}