初级排序之冒泡排序，插入排序，选择排序比较

最近读《算法》，这本书把插入排序，选择排序两种排序方法的优缺点，适用场合，效率分析的非常透彻，文章标题的冒泡算法是我自己加进去的，下面我们会以java代码来比较三种算法。

1.选择排序

选择排序的基本思想是从数组中找出最大/最小的那个元素，把它和数组第一的元素交换，然后在下一轮中找出剩余数组中最大/最小的元素，把它和数组第二个元素交换，依次类推。package sort;

import java.util.Arrays;

/**
* Created by 灵魂都在冒香气的神 on 2018/2/24.
* 升序排序
*/
public class SelectSort
{
public static void sort(int[] a)
{
int min_index=0,tmp;
for (int i=0;i<a.length;i++)
{
min_index=i;
for (int j=i+1;j<a.length-1;j++)
{
if (a[min_index]>a[j])
{
min_index=j;
}
}
Util.exchange(a,min_index,i);
}
}

public static void main(String[] args)
{
int[] num=Util.random(100);
SelectSort.sort(num);
Util.print(num);
}
}

2.插入排序

插入排序是指在一个有序序列中不断插入元素，使这个序列维持有序的状态，讲的不是很好，还是直接看代码吧package sort;

/**
* Created by 灵魂都在冒香气的神 on 2018/2/24.
*/
public class InsertSort
{
public static void sort(int[] a)
{
for (int i=0;i<a.length;i++)
{
for (int j=i;j>0&&a[j]<a[j-1];j--)
{

Util.exchange(a,j-1,j);
}
}
}
}

3.冒泡排序

      冒泡排序可能是最简单的一种排序算法，可能每个教C语言的老师都会给学生讲这种算法吧，但是，经过测试，冒泡算法是三种算法中效率最低的。
它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。

package sort;

/**
* Created by 灵魂都在冒香气的神 on 2018/2/24.
*/
public class BubbleSort
{
public static void sort(int[] a)
{
for (int i=0;i<a.length;i++)
{
for (int j=0;j<a.length-i-1;j++)
{
if (a[j]>a[j+1])
{
Util.exchange(a,j,j+1);
}
}
}
}
}

4.开始测试

我们先写一个工具类，里面有两个方法：random()和exchange()，分别用产生随机数组和交换数组的两个元素。package sort;

import java.util.Random;

/**
* Created by 灵魂都在冒香气的神 on 2018/2/24.
*/
public class Util
{
public static void exchange(int[] a,int x,int y)
{
int tmp=a[x];a[x]=a[y];a[y]=tmp;
}

public static int[] random(int count)
{
Random raner=new Random();
int[] num=new int[count];
for (int i=0;i<count;i++)
{
num[i]=raner.nextInt(count);
}
return num;
}
public static void print(int[] a)
{
for (int i=0;i<a.length;i++)
{
System.out.println(a[i]);
}
}
}
然后是测试类Test，测试处理十万个数据三种算法所需要的时间。package sort;

/**
* Created by 灵魂都在冒香气的神 on 2018/2/24.
*/
public class Test
{
public static void main(String[] args)
{

int[] num=Util.random(1000*100); //产生10万个随机数
/*复制数组副本*/
int[] a=num.clone();
int[] b=num.clone();
int[] c=num.clone();

long start=System.currentTimeMillis();
InsertSort.sort(a);
long end=System.currentTimeMillis();
System.out.println("插入排序耗时:"+(end-start)/1000.0);

start=System.currentTimeMillis();
BubbleSort.sort(b);
end=System.currentTimeMillis();
System.out.println("冒泡排序耗时:"+(end-start)/1000.0);

start=System.currentTimeMillis();
SelectSort.sort(c);
end=System.currentTimeMillis();
System.out.println("选择排序耗时:"+(end-start)/1000.0);
}
}

运行结果截图：



测试看出，在十万个随机数下，冒泡排序效率是最低的，插入排序效率最高。

5.结果分析

虽然三者的时间复杂度均为O(n^2)，但是三种算法的最好情况和最查情况是不一样的。在大量随机随机数下，随机序列越混乱，冒泡排序的效率就越低。序列越有序，插入排序的比较次数，交换次数就越少，最坏情况下约需要N^2/2次比较和N次数据交换，而选择排序的比较，交换次数和输入数据的混乱程度无关，大约需要N^2/2次比较和N次数据交换，与冒泡不同的是，虽然冒泡排序的排序次数也是大约N^2/2，但是，冒泡排序的数据交换次数是不确定的，和数据的混乱程度成正相关。所以，我们可以得出，不管数据有多混乱，或者数据相对有序，插入排序的效率>选择排序的效率>冒泡排序的效率。

以上是作者的拙见，作者还是大二学生，若是文章中出现错误，虚心接收意见。