(一)、冒泡排序(Bubble Sort)
1、原理
首先创建一个数组,里面存放着待排序的元素列表,我们如果需要把比较大的元素排在前面,把小的元素排在后面,那么需要从尾到头开始下面的比较操作:
(1)比较相邻的元素。如果第一个比第二个大,就交换他们两个。
(2)对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。
(3)针对所有的元素重复以上的步骤,除了最后一个。
(4)持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
2、动画演示
3、代码实现
#include <stdlib.h>
#include <stdio.h>
// 采用两层循环实现的方法。
// 参数arr是待排序数组的首地址,len是数组元素的个数。
void bubblesort1(int *arr,unsigned int len)
{
if (len<2) return; // 数组小于2个元素不需要排序。
int ii; // 排序的趟数的计数器。
int jj; // 每趟排序的元素位置计数器。
int itmp; // 比较两个元素大小时交换位置用到的临时变量。
int ifswap; // 每趟排序过程中是否交换过元素,0-未交换;1-有交换。
// 44,3,38,5,47,15,36,26,27,2,46,4,19,50,48
for (ii=len-1;ii>0;ii--) // 一共进行len-1趟比较。
{
printf("ii=%d\n",ii);
ifswap=0; // 初始化交换标志。
for (jj=0;jj<ii;jj++) // 每趟只需要比较0......ii之间的元素,ii之后的元素是已经排序好的。
{
if (arr[jj]>arr[jj+1]) // 如果前面的元素大于后面的元素,则交换它位的位置。
{
itmp=arr[jj+1];
arr[jj+1]=arr[jj];
arr[jj]=itmp;
ifswap=1; // 设置交换标志。
}
}
if (ifswap==0) return;
}
}
// 采用递归实现的方法。
// 参数arr是待排序数组的首地址,len是数组元素的个数。
void bubblesort2(int *arr,unsigned int len)
{
if (len<2) return; // 数组小于2个元素不需要排序。
printf("len=%d\n",len);
int ii; // 排序的元素位置计数器。
int itmp; // 比较两个元素大小时交换位置用到的临时变量。
int ifswap=0; // 排序过程中是否交换过元素,0-未交换;1-有交换。
for (ii=0;ii<len-1;ii++) // 每趟只需要比较0......len-1之间的元素,len-1之后的元素是已经排序好的。
{
if (arr[ii]>arr[ii+1]) // 如果前面的元素大于后面的元素,则交换它位的位置。
{
itmp=arr[ii+1];
arr[ii+1]=arr[ii];
arr[ii]=itmp;
ifswap=1; // 设置交换标志。
}
}
if (ifswap==0) return;
bubblesort2(arr,--len);
}
int main(int argc,char *argv[])
{
int arr[]={44,3,38,5,47,15,36,26,27,2,46,4,19,50,48};
int len=sizeof(arr)/sizeof(int);
bubblesort2(arr,len);
// 显示排序结果。
int ii;
for (ii=0;ii<len;ii++) printf("%2d ",arr[ii]);
printf("\n");
// system("pause"); // widnows下的C启用本行代码。
return 0;
}
4、性能特点
通过冒泡排序的算法思想,我们发现冒泡排序算法在每轮排序中会使一个元素排到一端,也就是最终需要 n-1 轮这样的排序(n 为待排序的数列的长度),而在每轮排序中都需要对相邻的两个元素进行比较。
在最坏的情况下,每次比较之后都需要交换位置,所以这里的时间复杂度是 O(n2)。其实冒泡排序在最好的情况下,时间复杂度可以达到 O(n),冒泡排序的平均时间复杂度是 O(n2)。
对于空间复杂度来说,冒泡排序用到的额外的存储空间只有一个,那就是用于交换位置的临时变量,其他所有操作都是在原有待排序列上处理的,所以空间复杂度为 O(1)。
(二)、选择排序(Selection Sort)
1、原理
选择排序(Selection-sort) 是一种简单直观的排序算法。它的工作原理:
首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。
2、动画演示
3、代码实现
#include <stdlib.h>
#include <stdio.h>
// 交换两个变量的值。
void swap(int *x,int *y)
{
int itmp=*x;
*x=*y;
*y=itmp;
}
// 采用两层循环实现的方法。
// 参数arr是待排序数组的首地址,len是数组元素的个数。
void selectsort1(int *arr,unsigned int len)
{
if (len<2) return; // 数组小于2个元素不需要排序。
int ileft,iright; // 每趟排序的最左和最右的位置。
int ii; // 每趟排序的元素位置计数器。
int iminpos; // 每趟循环选出的最小值的位置(数组的下标)。
int imaxpos; // 每趟循环选出的最大值的位置(数组的下标)。
ileft=0; iright=len-1; // ileft从0开始,iright从len-1开始。
while (ileft<iright)
{
iminpos=imaxpos=ileft;
for (ii=ileft;ii<=iright;ii++) // 每趟循环从ileft和iright之间选取元素。
{
// 找出值更小的元素,记下它的位置。
if (arr[ii]<arr[iminpos]) iminpos=ii;
// 找出值更大的元素,记下它的位置。
if (arr[ii]>arr[imaxpos]) imaxpos=ii;
}
// 如果本趟循环的最小的元素不是最左边的元素,则交换它们的位置。
if (iminpos!=ileft) swap(&arr[ileft],&arr[iminpos]);
// 如果imaxpos的位置是ileft,在上面的代码中ileft已被交换到了iminpos的位置。
// 所以imaxpos的值要修改为iminpos。
if (imaxpos==ileft) imaxpos=iminpos;
// 如果本趟循环的最大的元素不是最右边的元素,则交换它们的位置。
if (imaxpos!=iright) swap(&arr[iright],&arr[imaxpos]);
ileft++;
iright--;
}
}
// 采用递归实现的方法。
// 参数arr是待排序数组的首地址,len是数组元素的个数。
void selectsort2(int *arr,unsigned int len)
{
if (len<2) return;
int ii; // 每趟排序的元素位置计数器。
int iminpos=0; // 每趟循环选出的最小值的位置(数组的下标)。
int imaxpos=0; // 每趟循环选出的最大值的位置(数组的下标)。
int ileft=0;
int iright=len-1;
for (ii=ileft;ii<=iright;ii++) // 循环从ileft和iright之间选取元素。
{
// 找出值更小的元素,记下它的位置。
if (arr[ii]<arr[iminpos]) iminpos=ii;
// 找出值更大的元素,记下它的位置。
if (arr[ii]>arr[imaxpos]) imaxpos=ii;
}
// 如果本趟循环的最小的元素不是最左边的元素,则交换它们的位置。
if (iminpos!=ileft) swap(&arr[ileft],&arr[iminpos]);
// 如果imaxpos的位置是ileft,在上面的代码中ileft已被交换到了iminpos的位置。
// 所以imaxpos的值要修改为iminpos。
if (imaxpos==ileft) imaxpos=iminpos;
// 如果本趟循环的最大的元素不是最右边的元素,则交换它们的位置。
if (imaxpos!=iright) swap(&arr[iright],&arr[imaxpos]);
len=len-2;
selectsort2(++arr,len);
}
int main(int argc,char *argv[])
{
int arr[]={44,3,38,5,47,15,36,26,27,2,46,4,19,50,48};
int len=sizeof(arr)/sizeof(int);
// selectsort1(arr,len); // 采用两层循环排序的方法。
selectsort2(arr,len); // 采用递归排序的方法。
// 显示排序结果。
int jj; for (jj=0;jj<len;jj++) printf("%2d ",arr[jj]); printf("\n");
// system("pause"); // widnows下的C启用本行代码。
return 0;
}
4、性能特点
选择排序是表现最稳定的排序算法之一 ,因为无论什么数据进去都是O(n2)的时间复杂度 ,所以用到它的时候,数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。
(三)、插入排序(Insertion Sort)
插入排序(Insertion-Sort) 的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。
1、算法描述
一般来说,插入排序都采用in-place在数组上实现。具体算法描述如下:
步骤1: 从第一个元素开始,该元素可以认为已经被排序;
步骤2: 取出下一个元素,在已经排序的元素序列中从后向前扫描;
步骤3: 如果该元素(已排序)大于新元素,将该元素移到下一位置;
步骤4: 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置;
步骤5: 将新元素插入到该位置后;
步骤6: 重复步骤2~5。
2、动图演示
3、代码实现
#include <stdlib.h>
#include <stdio.h>
// 参数arr是待排序数组的首地址,len是数组元素的个数。
void insertsort(int *arr,unsigned int len)
{
if (len<2) return; // 数组小于2个元素不需要排序。
int itmp; // 当前需要排序的元素的值。
int ii; // 需要排序元素的计数器。
int jj; // 插入排序时,需要后移元素的计数器。
for (ii=1;ii<len;ii++)
{
itmp=arr[ii]; // 待排序元素
// 从已排序的最右边开始,把大于当前排序的元素后移。
// for (jj=ii-1;(jj>=0&&arr[jj]>itmp);jj--)
for (jj=ii-1;jj>=0;jj--)
{
if (arr[jj]<=itmp) break;
arr[jj+1]=arr[jj]; // 逐个元素后移。
}
arr[jj+1]=itmp; // 插入当前排序元素。
}
}
int main(int argc,char *argv[])
{
int arr[]={44,3,38,5,47,15,36,26,27,2,46,4,19,50,48};
int len=sizeof(arr)/sizeof(int);
insertsort(arr,len); // 调用插入排序函数对数组排序。
// 显示排序结果。
int yy; for (yy=0;yy<len;yy++) printf("%2d ",arr[yy]); printf("\n");
// system("pause"); // widnows下的C启用本行代码。
return 0;
}
4、性能特点
插入排序(Insertion-Sort) 的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。
(四)、希尔排序(Shell Sort)
1、算法描述
希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。
2、动画演示
3、代码实现
#include <stdlib.h>
#include <stdio.h>
// 对希尔排序中的单个组进行排序。
// arr-待排序的数组,len-数组总的长度,ipos-分组的起始位置,istep-分组的步长(增量)。
void groupsort(int *arr, int len, int ipos,int istep)
{
int itmp; // 当前需要排序的元素的值。
int ii; // 需要排序元素的计数器。
int jj; // 插入排序时,需要后移元素的计数器。
for (ii=ipos+istep;ii<len;ii=ii+istep)
{
itmp=arr[ii]; // 待排序元素
// 从已排序的最右边开始,把大于当前排序的元素后移。
// for (jj=ii-istep;(jj>=0&&arr[jj]>itmp);jj=jj-istep)
for (jj=ii-istep;jj>=0;jj=jj-istep)
{
if (arr[jj]<=itmp) break;
arr[jj+istep]=arr[jj]; // 逐个元素后移。
}
arr[jj+istep]=itmp; // 插入当前排序元素。
}
}
// 希尔排序,arr是待排序数组的首地址,len是数组的大小。
void shellsort(int *arr,unsigned int len)
{
int ii,istep;
// istep为步长,每次减为原来的一半取整数,最后一次必定为1。
for (istep=len/2;istep>0;istep=istep/2)
{
// 共istep个组,对每一组都执行插入排序。
for (ii=0;ii<istep;ii++)
{
groupsort(arr,len,ii,istep);
}
}
}
int main(int argc,char *argv[])
{
int arr[]={44,3,38,5,47,15,36,26,27,2,46,4,19,50,48};
int len=sizeof(arr)/sizeof(int);
shellsort(arr,len); // 调用插入排序函数对数组排序。
// 显示排序结果。
int yy; for (yy=0;yy<len;yy++) printf("%2d ",arr[yy]); printf("\n");
// system("pause"); // widnows下的C启用本行代码。
return 0;
}
4、性能特点
**希尔排序的执行时间依赖于增量序列。 **
希尔排序耗时的操作有:比较 + 后移赋值。
时间复杂度情况如下:(n指待排序序列长度)
**1) 最好情况:**序列是正序排列,在这种情况下,需要进行的比较操作需(n-1)次。后移赋值操作为0次。即O(n)
**2) 最坏情况:**O(nlog2n)。
**3) 渐进时间复杂度(平均时间复杂度):**O(nlog2n)
(五)、归并排序(Merge Sort)
1、算法描述
归并排序是建立在归并操作上的一种有效的排序算法。该算法采用分治法。归并排序是一种稳定的排序方法。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为2-路归并。
步骤1:把长度为n的输入序列分成两个长度为n/2的子序列;
步骤2:对这两个子序列分别采用归并排序;
步骤3:将两个排序好的子序列合并成一个最终的排序序列。
2、动图演示
3、代码实现
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int min(int x,int y) { return x<y ? x : y; } // 取x和y中的较小者的值。
// 采用循环实现归并排序,arr-待排序数组的首地址,len--待排序数组的长度。
void mergesort(int *arr,unsigned int len)
{
if (len<2) return; // 小于两个元素不需要排序。
int *aa=arr; // aa指向待排序的数组。
int *bb=(int *)malloc(len*sizeof(int)); // bb指向已排序的数组。
int iseg; // 区间分段的计数器,1,2,4,8,16,...
int istart; // 区间起始位置的计数器。
// 排序的趟数的循环。
for (iseg=1;iseg<len;iseg=iseg*2)
{
// 每趟排序选取区间的循环。
for (istart=0;istart<len;istart=istart+iseg*2)
{
// 把每个区间分成两部分,ilow是起始位置,imid是中间位置,imax是结束位置。
int ilow=istart;
int imid=min(istart+iseg,len); // 考虑分段不均的情况,imid不能超出len。
int imax=min(istart+iseg*2,len); // 考虑分段不均的情况,imax也不能超出len。
int ii=ilow; // 已排序数组的计数器。
int istart1=ilow,iend1=imid; // 待排序左边数列的起始和结束位置。
int istart2=imid,iend2=imax; // 待排序右边数列的起始和结束位置。
// 把待排序左右两边数列合并到已排序数组。
while ((istart1<iend1) && (istart2<iend2))
bb[ii++]=aa[istart1]<aa[istart2] ? aa[istart1++] : aa[istart2++];
// 把左边数列其它的元素追加到已排序数组。
while (istart1<iend1) bb[ii++]=aa[istart1++];
// 把右边数列其它的元素追加到已排序数组。
while (istart2<iend2) bb[ii++]=aa[istart2++];
}
// 交换一下两个数组的指针,准备下一趟的排序。
int *ptmp=aa; aa=bb; bb=ptmp;
}
// 如果aa指向的不是原始数组的指针,把aa中的内容复制到arr中。
if (aa != arr)
{
memcpy(arr,aa,len*sizeof(int));
bb = aa;
}
free(bb);
}
int main(int argc,char *argv[])
{
int arr[]={44,3,38,5,47,15,36,26,27,2,46,4,19,50,48,10};
int len=sizeof(arr)/sizeof(int);
mergesort(arr,len);
// 显示排序结果。
int yy; for (yy=0;yy<len;yy++) printf("%2d ",arr[yy]); printf("\n");
// system("pause"); // widnows下的C启用本行代码。
return 0;
}
4、性能特点
和选择排序一样,归并排序的性能不受输入数据的影响,但表现比选择排序好的多,因为始终都是O(n log n)的时间复杂度。代价是需要额外的内存空间。