为了账号安全,请及时绑定邮箱和手机立即绑定

排序

标签:
C++

6.1 排序的基本概念:

  1. 稳定:若相等的两个A,B,若在排序前的序列中A领先于B,经过排序后A仍然领先于B,则称所用的排序方法是稳定的。反之,若发生变化,则是不稳定的

6,2 插入类排序:

    插入排序的基本思想是:在一个已排好序的记录子集的基础上,将待排序的记录有序地插入到记录自己中,直到所有待排序记录去全部插入为止。

void InsSort(RecordType r[],int length){

    for(i=2;i<=length;i++){
    r[0]=r[i];j=i-1;
    while(x.key<r[j].key){
        r[j+1]=r[j]; j--;
    }
    r[j+1] = r[0];
}

6.3 希尔排序

    希尔排序的算法思想:将待排序数组按照步长gap进行分组,然后将每组的元素利用直接插入排序的方法进行排序;每次将gap折半减少,循环上述操作;当gap等于1时,利用直接插入,完成排序。

void ShellSort (ElemType A[],int n){
//对顺序表作希尔插入排序,基本算法和直接插入排序相比,做了以下修改:
//1.前后记录位置的增量是dk,不是1
//2.r[0]只是暂时存储单元,不是哨兵,当j<=0时,插入位置已到
    for(dk=n/2;dk>=1;dk=dk/2)
        for(i=dk+1;i<=n;i++)
            if(A[i].key<A[i-dk].key){                        
             //需将A[i]插入有序增量子表                    
                    A[0]=A[i];                                            
                           for(j=i-dk;j>0&&A[0].key<A[j].key;j-=dk)     
                           A[j+dk]=A[j];           //记录后移,查找插入位置   
                           A[j+dk]=A[0];                //插入   
                      }//if
}
稳定性:当相同关键字的记录被划分到不同的子表时,可能会改变它们之间的相对次序,因此,希尔排序是一种不稳定的排序方法。例如,表L=[3,2,2].经过一趟排序后,L=[2,2,3],最终排序序列也是L=[2,2,3],显然2与2的相对次序已经发生了变化。


时间复杂度:O(N*logN)

6.4简单选择排序:

  • 从待排序序列中,找到关键字最小的元素;

  • 如果最小元素不是待排序序列的第一个元素,将其和第一个元素互换

  • 从余下的n-1个元素中,找出关键字最小的元素,重复(1)、(2)步,直到排序结束。

        选择排序的时间复杂度为O(n²),由于每次选择仅考虑某一位置上的数据情况,可能会破坏之前数据的相对位置,因此它是一种不稳定的排序方法。 例如:序列  [9,9,1]第一次就将第一个[9]与[1]交换,导致第一个9挪动到第二个9后面。

补充:简单选择排序的比较次数与序列的初始排序无关。假设待排序的序列有 n个元素。 则比较次数永远都是n(n-1)/2; 而移动次数(即:交换操作)与序列的初始排序有关,介于 0 和 (n - 1) 次之间。当序列正序时,移动次数最少,为 0。当序列反序时,移动次数最多,为n - 1 次;逆序交换n/2次。选择排序的移动次数比冒泡排序少多了,由于交换所需CPU时间比 比较所需的CPU时间多,n值较小时,选择排序比冒泡排序快。

6.5冒泡排序:

  • 将序列当中的左右元素,依次比较,保证右边的元素始终大于左边的元素;

    (第一轮结束后,序列最后一个元素一定是当前序列的最大值)

  • 对序列当中剩下的n-1元素在执行步骤1

  • 对于长度为n的序列,一共需要执行n-1轮比较(利用while循环可以减少执行次数)

void BubbleSort (ElemType A[],int n){
//用冒泡排序将序列A中的元素按从小到大排列       
          for(i=0;i<n-1;i++){             
                      flag=false;        //标示本趟冒泡是否发生交换标志              
                for(j=n-1;j>i;j--)              
                      //一趟冒泡过程                  
                   if(A[j-i].key>A[j].key){    
                           //若为逆序                        
                            swap(A[j-1],A[j]);       //交换        
                             flag=true;              
                                    }          
                           if(flag==false)       
                               return;  //本趟遍历没有发生交换,说明已经有序 
        }
}

    稳定性:冒泡排序是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较,交换也发生在这两个元素之间。相同元素的前后顺序并没有改变,冒泡排序是一种稳定排序算法。

5.时间复杂度: O(n²)

7.基数排序(桶排序)
1.基本概念
  基数排序(Radix Sort)属于分配式排序,又称"桶子法"(Bucket Sort或Bin Sort),将要排序的元素分配到某些"桶"中,以达到排序的作用。基数排序属于稳定的排序,其时间复杂度为nlog(r)m (其中r为的采取的基数,m为堆数),基数排序的效率有时候高于其它比较性排序。

 1. 根据输入建立适当个数的桶,每个桶可以存放某个范围内的元素;
 2.将落在特定范围内的所有元素放入对应的桶中;
 3.对每个非空的桶中元素进行排序,可以选择通用的排序方法,比如插入、快排;
 4.按照划分的范围顺序,将桶中的元素依次取出。排序完成。

归并排序:

https://img2.sycdn.imooc.com/5e73641500016d5607200771.jpg

https://img1.sycdn.imooc.com//5e73650400011a1608440529.jpg


点击查看更多内容
TA 点赞

若觉得本文不错,就分享一下吧!

评论

作者其他优质文章

正在加载中
  • 推荐
  • 评论
  • 收藏
  • 共同学习,写下你的评论
感谢您的支持,我会继续努力的~
扫码打赏,你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫,即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消