注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

信息 灵感 创新

I? =Information,Inspiration,Innovation

 
 
 

日志

 
 
关于我

we are 5. Mathematics, Computation, Programming, Engineering, and Making fun of life.

网易考拉推荐

【转载】常见排序算法分析  

2014-07-22 10:19:12|  分类: C & C++ |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |
本文转载自奈落之夜《常见排序算法分析》

一、常见算法复杂度比较

序号

 排序类别

时间复杂度

空间复杂度

稳定

1

插入排序

O(n2)

1

2

希尔排序

O(n2)

1

×

3

冒泡排序

O(n2)

1

4

选择排序

O(n2)

1

×

5

快速排序

O(Nlogn)

O(logn)

×

6

堆排序

O(Nlogn)

1

×

7

归并排序

O(Nlogn)

O(n)

二、各种算法

一、插入排序(Insertion Sort)

1. 基本思想:

  每次将一个待排序的数据元素,插入到前面已经排好序的数列中的适当位置,使数列依然有序;直到待排序数据元素全部插入完为止。

2. 排序过程: 

【示例】:

[初始关键字] [49] 38 65 97 76 13 27 49

    J=2(38) [38 49] 65 97 76 13 27 49

    J=3(65) [38 49 65] 97 76 13 27 49

    J=4(97) [38 49 65 97] 76 13 27 49

    J=5(76) [38 49 65 76 97] 13 27 49

    J=6(13) [13 38 49 65 76 97] 27 49

    J=7(27) [13 27 38 49 65 76 97] 49

    J=8(49) [13 27 38 49 49 65 76 97] 

二、选择排序

1. 基本思想:

  每一趟从待排序的数据元素中选出最小(或最大)的一个元素,顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。

2. 排序过程:

【示例】:

  初始关键字 [49 38 65 97 76 13 27 49]

第一趟排序后 13 [38 65 97 76 49 27 49]

第二趟排序后 13 27 [65 97 76 49 38 49]

第三趟排序后 13 27 38 [97 76 49 65 49]

第四趟排序后 13 27 38 49 [49 97 65 76]

第五趟排序后 13 27 38 49 49 [97 97 76]

第六趟排序后 13 27 38 49 49 76 [76 97]

第七趟排序后 13 27 38 49 49 76 76 [ 97]

最后排序结果 13 27 38 49 49 76 76 97

三、冒泡排序(BubbleSort)

1. 基本思想:  两两比较待排序数据元素的大小,发现两个数据元素的次序相反时即进行交换,直到没有反序的数据元素为止。

2. 排序过程:

  设想被排序的数组R[1..N]垂直竖立,将每个数据元素看作有重量的气泡,根据轻气泡不能在重气泡之下的原则,从下往上扫描数组R,凡扫描到违反本原则的轻气泡,就使其向上"漂浮",如此反复进行,直至最后任何两个气泡都是轻者在上,重者在下为止。

【示例】:

49 13 13 13 13 13 13 13

38 49 27 27 27 27 27 27

65 38 49 38 38 38 38 38

97 65 38 49 49 49 49 49

76 97 65 49 49 49 49 49

13 76 97 65 65 65 65 65

27 27 76 97 76 76 76 76

49 49 49 76 97 97 97 97

四、快速排序(Quick Sort)

1. 基本思想:在当前无序区R[1..H]中任取一个数据元素作为比较的"基准"(不妨记为X),用此基准将当前无序区划分为左右两个较小的无序区:R[1..I-1]和R[I+1..H],且左边的无序子区中数据元素均小于等于基准元素,右边的无序子区中数据元素均大于等于基准元素,而基准X则位于最终排序的位置上,即R[1..I-1]≤X.Key≤R[I+1..H](1≤I≤H),当R[1..I-1]和R[I+1..H]均非空时,分别对它们进行上述的划分过程,直至所有无序子区中的数据元素均已排序为止。

2. 排序过程:

【示例】:

初始关键字 [49 38 65 97 76 13 27 49]

第一次交换后 [27 38 65 97 76 13 49 49]

第二次交换后 [27 38 49 97 76 13 65 49]

J向左扫描,位置不变,第三次交换后 [27 38 13 97 76 49 65 49]

I向右扫描,位置不变,第四次交换后 [27 38 13 49 76 97 65 49]

J向左扫描 [27 38 13 49 76 97 65 49]

(一次划分过程)

初始关键字 [49 38 65 97 76 13 27 49]

一趟排序之后 [27 38 13] 49 [76 97 65 49]

二趟排序之后 [13] 27 [38] 49 [49 65]76 [97]

三趟排序之后 13 27 38 49 49 [65]76 97

最后的排序结果 13 27 38 49 49 65 76 97

五、堆排序(Heap Sort)
1. 基本思想:
  堆排序是一树形选择排序,在排序过程中,将R[1..N]看成是一颗完全二叉树的顺序存储结构,利用完全二叉树中双亲结点和孩子结点之间的内在关系来选择最小的元素。
2. 堆的定义: N个元素的序列K1,K2,K3,...,Kn.称为堆,当且仅当该序列满足特性:
       Ki≤K2i Ki ≤K2i+1(1≤ I≤ [N/2])

  堆实质上是满足如下性质的完全二叉树:树中任一非叶子结点的关键字均大于等于其孩子结点的关键字。例如序列10,15,56,25,30,70就是一个堆,它对应的完全二叉树如上图所示。这种堆中根结点(称为堆顶)的关键字最小,我们把它称为小根堆。反之,若完全二叉树中任一非叶子结点的关键字均大于等于其孩子的关键字,则称之为大根堆。
3. 排序过程:
堆排序正是利用小根堆(或大根堆)来选取当前无序区中关键字小(或最大)的记录实现排序的。我们不妨利用大根堆来排序。每一趟排序的基本操作是:将当前无序区调整为一个大根堆,选取关键字最大的堆顶记录,将它和无序区中的最后一个记录交换。这样,正好和直接选择排序相反,有序区是在原记录区的尾部形成并逐步向前扩大到整个记录区。
 【示例】:对关键字序列42,13,91,23,24,16,05,88建堆 

常见排序算法分析 - 熊哥 - 熊哥常见排序算法分析 - 熊哥 - 熊哥常见排序算法分析 - 熊哥 - 熊哥常见排序算法分析 - 熊哥 - 熊哥常见排序算法分析 - 熊哥 - 熊哥

三、稳定性分析

首先,排序算法的稳定性大家应该都知道,通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。在简单形式化一下,如果Ai = Aj, Ai原来在位置前,排序后Ai还是要在Aj位置前。

     其次,说一下稳定性的好处。排序算法如果是稳定的,那么从一个键上排序,然后再从另一个键上排序,第一个键排序的结果可以为第二个键排序所用。基数排序就是这样,先按低位排序,逐次按高位排序,低位相同的元素其顺序再高位也相同时是不会改变的。另外,如果排序算法稳定,对基于比较的排序算法而言,元素交换的次数可能会少一些(个人感觉,没有证实)。

     回到主题,现在分析一下常见的排序算法的稳定性,每个都给出简单的理由。

   (1)冒泡排序

        冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较,交换也发生在这两个元素之间。所以,如果两个元素相等,我想你是不会再无聊地把他们俩交换一下的;如果两个相等的元素没有相邻,那么即使通过前面的两两交换把两个相邻起来,这时候也不会交换,所以相同元素的前后顺序并没有改变,所以冒泡排序是一种稳定排序算法。

(2)选择排序

      选择排序是给每个位置选择当前元素最小的,比如给第一个位置选择最小的,在剩余元素里面给第二个元素选择第二小的,依次类推,直到第n-1个元素,第n个元素不用选择了,因为只剩下它一个最大的元素了。那么,在一趟选择,如果当前元素比一个元素小,而该小的元素又出现在一个和当前元素相等的元素后面,那么交换后稳定性就被破坏了。比较拗口,举个例子,序列5 8 5 2 9, 我们知道第一遍选择第1个元素5会和2交换,那么原序列中2个5的相对前后顺序就被破坏了,所以选择排序不是一个稳定的排序算法。

(3)插入排序
     插入排序是在一个已经有序的小序列的基础上,一次插入一个元素。当然,刚开始这个有序的小序列只有1个元素,就是第一个元素。比较是从有序序列的末尾开始,也就是想要插入的元素和已经有序的最大者开始比起,如果比它大则直接插入在其后面,否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的,那么插入元素把想插入的元素放在相等元素的后面。所以,相等元素的前后顺序没有改变,从原无序序列出去的顺序就是排好序后的顺序,所以插入排序是稳定的。

(4)快速排序
    快速排序有两个方向,左边的i下标一直往右走,当a[i] <= a[center_index],其中center_index是中枢元素的数组下标,一般取为数组第0个元素。而右边的j下标一直往左走,当a[j] > a[center_index]。如果i和j都走不动了,i <= j, 交换a[i]和a[j],重复上面的过程,直到i>j。 交换a[j]和a[center_index],完成一趟快速排序。在中枢元素和a[j]交换的时候,很有可能把前面的元素的稳定性打乱,比如序列为 5 3 3 4 3 8 9 10 11, 现在中枢元素5和3(第5个元素,下标从1开始计)交换就会把元素3的稳定性打乱,所以快速排序是一个不稳定的排序算法,不稳定发生在中枢元素和a[j]交换的时刻。

(5)归并排序
    归并排序是把序列递归地分成短序列,递归出口是短序列只有1个元素(认为直接有序)或者2个序列(1次比较和交换),然后把各个有序的段序列合并成一个有序的长序列,不断合并直到原序列全部排好序。可以发现,在1个或2个元素时,1个元素不会交换,2个元素如果大小相等也没有人故意交换,这不会破坏稳定性。那么,在短的有序序列合并的过程中,稳定是是否受到破坏?没有,合并过程中我们可以保证如果两个当前元素相等时,我们把处在前面的序列的元素保存在结果序列的前面,这样就保证了稳定性。所以,归并排序也是稳定的排序算法。

(6)基数排序
   基数排序是按照低位先排序,然后收集;再按照高位排序,然后再收集;依次类推,直到最高位。有时候有些属性是有优先级顺序的,先按低优先级排序,再按高优先级排序,最后的次序就是高优先级高的在前,高优先级相同的低优先级高的在前。基数排序基于分别排序,分别收集,所以其是稳定的排序算法。

(7)希尔排序(shell)
    希尔排序是按照不同步长对元素进行插入排序,当刚开始元素很无序的时候,步长最大,所以插入排序的元素个数很少,速度很快;当元素基本有序了,步长很小,插入排序对于有序的序列效率很高。所以,希尔排序的时间复杂度会比o(n^2)好一些。由于多次插入排序,我们知道一次插入排序是稳定的,不会改变相同元素的相对顺序,但在不同的插入排序过程中,相同的元素可能在各自的插入排序中移动,最后其稳定性就会被打乱,所以shell排序是不稳定的。

(8)堆排序
   我们知道堆的结构是节点i的孩子为2*i和2*i+1节点,大顶堆要求父节点大于等于其2个子节点,小顶堆要求父节点小于等于其2个子节点。在一个长为n的序列,堆排序的过程是从第n/2开始和其子节点共3个值选择最大(大顶堆)或者最小(小顶堆),这3个元素之间的选择当然不会破坏稳定性。但当为n/2-1, n/2-2, ...1这些个父节点选择元素时,就会破坏稳定性。有可能第n/2个父节点交换把后面一个元素交换过去了,而第n/2-1个父节点把后面一个相同的元素没有交换,那么这2个相同的元素之间的稳定性就被破坏了。所以,堆排序不是稳定的排序算法。

综上,得出结论: 选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法,而冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。还有一些排序算法我没有进行

五、java实现

import java.io.*;

 

interface Item

{

public boolean less(Item v);

}

 

class Recod

{

int id;

String name;

double balance;

static int flag=2;

}

 

class Sort

{

static boolean less(Item v,Item w)

{

return v.less(w);

}

static void compExch(Item a[],int i,int j)

{

if(less(a[i],a[j]))

exch(a,i,j);

}

static void exch(Item a[],int i,int j)

{

Item t=a[i]; a[i]=a[j]; a[j]=t;

}

//选择排序

static void selSort(Item a[],int l,int r)

{

for(int i=l;i<=r;i++)

{

int max=i;

for(int j=i+1;j<=r;j++)

{

if(less(a[max],a[j])) max=j;

}

if(max!=i)

exch(a,i,max);

}

}

//冒泡

static void maoSort(Item a[],int l,int r)

{

for(int i=l;i<=r;i++)

{

int flag=1;

for(int j=r;j>i;j--)

{

if(less(a[j-1],a[j]))

{

exch(a,j-1,j);

flag=0;

}

 

}

if(flag==1) break;

}

 

}

//插入

static void insertSort(Item a[],int l,int r)

{

Item item;

int j=0;

for(int i=1+l;i<=r;i++)

{

item=a[i];

j=i-1;

while(j>=l && less(a[j],item))

{

a[j+1]=a[j];

j--;

}

a[j+1]=item;

}

}

//快排(三路取中加小文件截断)

static void quickSort(Item a[],int l,int r)

{

if((r-l)<=10) insertSort(a,l,r);

else

{

if(l<r)

{

int i=l,j=r,k=(l+r)/2;

compExch(a,r,k);

compExch(a,r,l);

compExch(a,k,l);

exch(a,k,l);

Item item=a[i];

while(i!=j)

{

while(i<j && less(a[j],item))

j--;

if(i<j)

{

a[i]=a[j];

i++;

}

while(i<j && less(item,a[i]))

i++;

if(i<j)

{

a[j]=a[i];

j--;

}

}

a[i]=item;

quickSort(a,l,i-1);

quickSort(a,i+1,r);

}

}

}

//希尔排序

static void shellSort(Item a[],int l,int r)

{

int d=r/2;

Item item;

while(d>0)

{

for(int i=d;i<=r;i++)

{

int j=i-d;

while(j>=l && less(a[j],a[j+d]))

{

item=a[j];

a[j]=a[j+d];

a[j+d]=item;

j=j-d;

}

}

d=d/2;

}

}

}

 

public class Quick extends Recod implements Item

{

 

 

public boolean less(Item v)

{

Quick qu=(Quick)v;

switch(flag)

{

case 2: return id<qu.id;

case 1: return name.compareTo(qu.name)<0;

default:return balance<qu.balance;

}

}

public static void main(String[]args)

{

Quick a[]=new Quick[2000];

for(int i=0;i<2000;i++)

{

a[i]=new Quick();

a[i].id=(int)(1+Math.round(Math.random()*100));

a[i].name="ren"+String.valueOf(i);

a[i].balance=10+Math.random()*100;

System.out.println(a[i].id+" "+a[i].balance);

}

Sort.quickSort(a,0,1999);

System.out.println("**************");

if(flag==2)

for(int j=0;j<2000;j++)

{

System.out.println(a[j].id+" "+a[j].name);

}

else

{

for(int j=0;j<2000;j++)

System.out.println(a[j].balance+" "+a[j].name);

}

}

}

六、说明比较:

插入、冒泡排序的速度较慢,但参加排序的序列局部或整体有序时,这种排序能达到较快的速度。

反而在这种情况下,快速排序反而慢了。

当n较小时,对稳定性不作要求时宜用选择排序,对稳定性有要求时宜用插入或冒泡排序。

若待排序的记录的关键字在一个明显有限范围内时,且空间允许是用桶排序。

当n较大时,关键字元素比较随机,对稳定性没要求宜用快速排序。

当n较大时,关键字元素可能出现本身是有序的,对稳定性有要求时,空间允许的情况下。

宜用归并排序。

当n较大时,关键字元素可能出现本身是有序的,对稳定性没有要求时宜用堆排序。

 

内容都来源于网络,有一些是下载到的word里面的,然后总结的,感谢作者。这里供我学习用。

  评论这张
 
阅读(468)| 评论(0)
推荐 转载

历史上的今天

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2016