Chinaunix首页 | 论坛 | 博客
  • 博客访问: 754020
  • 博文数量: 231
  • 博客积分: 3217
  • 博客等级: 中校
  • 技术积分: 2053
  • 用 户 组: 普通用户
  • 注册时间: 2011-07-04 12:01
文章分类

全部博文(231)

文章存档

2015年(1)

2013年(10)

2012年(92)

2011年(128)

分类: C/C++

2012-09-17 15:09:41

排序用到的数据结构:

点击(此处)折叠或打开

  1. #define MAXSIZE 10
  2. typedef struct
  3. {
  4. int r[MAXSIZE+1];//用于存储要排序数组,r[0]用作临时变量
  5. int length;//用于记录顺序表的长度
  6. }SqList;

  7. void swap(SqList *L,int i,int j)
  8. {
  9. int temp=L->r[i];
  10. L->r[i]=L->r[j];
  11. L->r[j]=temp;
  12. }

冒泡排序一种交换排序,它的基本思想是:两两比较相邻记录的关键字,如果反序则交换,知道没有反序的记录为止。

点击(此处)折叠或打开

  1. void BubbleSort0(SqList *L)
  2. {
  3. int i,j;
  4. for(i=1;i<L->length;j++)
  5. {
  6.    for(j=i+1;j<L->length;j++)
  7.     {
  8.        if(L->r[i]>L->r[j])
  9. {
  10.         swap(L,i,j);//交换L->r[i]和L->r[j]的值
  11. }
  12. }
  13. }
  14. }
这个算是简单的交换排序,算法效率非常低。正宗的冒泡排序:

点击(此处)折叠或打开

  1. void BubbleSort(SqList *L){
  2. int i,j;
  3. for(i=1;i<L->length;i++)
  4. {
  5. for(j=L->length-1;j>=i;j--)
  6.   {
  7.       if(L->r[i]>L->r[j+1])//若前者大于后者注意跟上一个算法的差异
  8.       {swap(L,j,j+1;)}
  9. }
  10. }
  11. }

冒泡排序优化:主要是由一些序列不需要全部都比较

点击(此处)折叠或打开

  1. void BubbleSort2(SqList *L)
  2. {
  3. int i,j;
  4. Status flag=TRUE;
  5. for(i=1;i<L->length && flag;i++)//若flag为true则推出循环
  6. {
  7. flag=FALSE;
  8. for(j=L->length-1;j>=i;j--)
  9. {
  10.   if(L->r[j]>L->r[j+1])
  11.    {
  12.     swap(L,j,j+1);
  13.     flag=TRUE;//如果有数据交换则flag为true
  14. }
  15. }
  16. }
  17. }
冒泡排序法最坏情况下时间复杂度O(n的平方)
 
简单选择排序法就是通过n-i次关键字间的比较,从n-i+1个记录中选择出关键字最小的记录,冰河第i(1《i《n)个记录交换之。

点击(此处)折叠或打开

  1. void SelectSort(SqList *L)
  2. {
  3. int i,j,min;
  4. for(i=1;i<L->length-1;i++)
  5. {
  6.   min=i;
  7.   for(j=i+1;j<L->length-1;j++)
  8. {
  9.    if(L->r[min]>L->r[j])//如果由小于当前最小值的关键字
  10.       min=j;//将此关键字的下标赋值给min
  11. }
  12. if(i!=min) //若min不等于找到最小值进行交换
  13. swap(L,i,min);
  14. }
  15. }
简单选择交换与交换完全雷同,简单交换是下标进行交换,所用的时间复杂度为O(n的平方)。在性能上要略优于冒泡排序。
 
直接插入排序的基本操作是将一个记录插入到已经排好序的有序列表中,从而得到一个新的、记录数增1的有序表。

点击(此处)折叠或打开

  1. void InsertSort(SqList *L)
  2. {
  3. int i,j;
  4. for(i=2;i<=L->length;i++)
  5. {
  6. if(L->r[i]<L->r[i-1])
  7. {
  8. L->r[0]=L->r[i];//设置哨兵
  9. for(j=i-1;L->r[j]>L->r[0];j--)
  10.   L->r[j+1]=L->r[j];//记录后移
  11. L->r[j+1]=L->r[0];//插入到正确位置
  12. }
  13. }
  14. }
直接插入排序复杂度分析最坏的情况:n*n/4   复杂度:O(n的平方)
 
 
希尔排序法:将相距某个“增量”的记录组成一个子序列,这样才能保证在子序列内分别进行直接插入排序后得到的结构是基本有序而不是局部有序。

点击(此处)折叠或打开

  1. //对顺序表L作希尔排序
  2. void ShellSort(SqList *L)
  3. {
  4. int i,j;
  5. int increment=L->length;
  6. do{
  7.   increament=increament/3+1;
  8.   for(i=increment+1;i<=L->length;i++)
  9. {
  10.   if(L->r[i]<L->r[i-increment])
  11. {
  12.   L->r[0]=L->r[i];
  13. for(j=i-increment;j>0&&L->r[0]<L->r[j];j-=increment)
  14. L->r[j+increment]=L->r[j];//记录后移,查找插入位置
  15. L->r[j+increment]=L->r[0;]
  16. }
  17. }
  18. }
  19. while(increment>1);
  20. }
当增量序列为dlta[k]=2t-k+1-1(02(n+1))可以获得不错的效果,时间复杂度为O(n的3/2方)
 


 堆排序的时间复杂度为O(nlogn)。由于堆排序堆原始记录的排序的状态不敏感,因此无论最好、最坏和平均时间复杂度均为O(nlogn)
归并排序复杂度的总的时间复杂度为O(nlogn),空间复杂度O(n+logn)
快速排序基本思想是:通过一趟排序将待排序记录分割成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可分别肚带这两部分记录继续进行排序,已达到整个序列有序的目的。

点击(此处)折叠或打开

  1. void QuickSort(SqList *L)
  2. {
  3. QSort(L,1,L->length);
  4. }

  5. void QSort(SqList *L,int low,int high)
  6. {
  7. int pivot;
  8. if(low<high){
  9. pivot=Partition(L,low,high);、、将L->r[low..high]一份为二
  10. QSort(L,low,pivot-1);//对低子表递归排序
  11. QSort(L,pivot+1,high);//对高子表递归排序
  12. }
  13. }



 
阅读(646) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~