基础排序总结（冒泡排序、选择排序、插入排序）

1、冒泡排序

1.1、简介与原理

冒泡排序算法运行起来非常慢，但在概念上它是排序算法中最简单的，因此冒泡排序算法在刚开始研究排序技术时是一个非常好的算法。

冒泡排序原理即：从数组下标为0的位置开始，比较下标位置为0和1的数据，如果0号位置的大，则交换位置，如果1号位置大，则什么也不做，然后右移一个位置，比较1号和2号的数据，和刚才的一样，如果1号的大，则交换位置，以此类推直至最后一个位置结束，到此数组中最大的元素就被排到了最后，之后再根据之前的步骤开始排前面的数据，直至全部数据都排序完成。

1.2、代码实现

public class ArraySort {

public static void main(String[] args) {
int[] array = {1, 7, 3, 9, 8, 5, 4, 6};
array = sort(array);
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}

public static int[] sort(int[] array) {
for (int i = 1; i < array.length; i++) {
for (int j = 0; j < array.length-i; j++) {
if (array[j] > array[j+1]) {
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
return array;
}
}

1.3、效率

一般来说，数组中有 N 个数据项，则第一趟排序中有 N-1 次比较，第二趟中有 N-2 次，以此类推。这种序列的求和公式如下：

（N-1）+（N-2）+（N-3）+…+1=N*（N-1）/2

当 N 为 10 时，N*（N-1）/2等于45（10*9/2）。

这样，算法作了约 N2/2 次比较（忽略减 1，不会有很大差别，特别是当 N 很大时）。

因为两两数据只有在需要时才交换，所以交换的次数少于比较的次数。如果数据是随机的，那么大概有一半数据需要交换，则交换的次数为 N2/4 。

交换和比较操作次数都和 N2 成正比。由于常数不算在大 O 表示法，可以忽略2 和 4，并且认为冒泡排序运行需要 O（N2）时间级别。运行大数量级别的数组可以证实这种排序算法的速度是很慢的。

无论何时，只要看到一个循环嵌套在另外一个循环里，例如在冒泡排序中，就可以怀疑这个算法的运行时间为 O（N2）级。外层循环执行 N 次，内部循环对于每一次外层循环都执行 N 次（或者几分之 N 次）。这就意味着将大约需要执行 N*N 或者 N2 次某个基本操作。

2、选择排序

2.1、简介与原理

选择排序改进了冒泡排序，将必要的交换次数从 O（N2）减少到 O（N）次。不幸的是比较次数仍然保持为 O（N2）。然而，选择排序仍然为大记录量的排序提出了一个非常重要的改进，因为这些大量的记录需要在内存中移动，这就使交换的时间和比较的时间相比起来，交换的时间更为重要。（一般来说，在 Java 语言中不是这种情况，Java 中只是改变了引用位置，而实际对象的位置并没有发生改变。）

选择排序原理即：在选择排序中，不再只比较两个相邻的数据。因此需要记录下某一个数据的下标，进行选择排序就是把所有的数据扫描一遍，从中挑出（按从小到大排序）最小的一个数据，这个最小的数据和最左端下标为0的数据交换位置。之后再次扫描数据，从下标为1开始，还是挑出最小的然后和1号位置进行交换，这个过程一直持续到所有的数据都排定。而程序中需要有一个标识变量来标识每次挑出最小数据的下标。

2.2、代码实现

public class ArraySort {

public static void main(String[] args) {
int[] array = {1, 7, 3, 9, 8, 5, 4, 6};
array = sort(array);
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}

public static int[] sort(int[] array) {
for (int i = 0; i < array.length; i++) {
int temp = i;
for (int j = i+1; j < array.length; j++) {
if (array[temp] > array[j]) {
temp = j;
}
}
int t = array[temp];
array[temp] = array[i];
array[i] = t;
}
return array;
}
}

2.3、效率

选择排序和冒泡排序执行了相同次数的比较：N*（N-1）/2。对于 10 个数据项，需要 45 次比较。然而，10 个数据项只需要少于 10次交换。对于 100 个数据项，需要 4950 次比较，但只进行了不到 100 次的交换。N 值很大时，比较的次数是主要的，所以结论是选择排序和冒泡排序一样运行了 O（N2）时间。但是，选择排序无疑更快，因为它进行的交换少得多。当 N 值较小时，特别是如果交换的时间级比比较的时间级大得多时，选择排序实际上是相当快的。

3、插入排序

3.1、简介与原理

在大多数情况下，插入排序算法是这三种排序中最好的一种。虽然插入排序算法仍然需要 O（N2）的时间，但是在一般情况下，它要比冒泡排序快一倍，比选择排序还要快一点。尽管它比冒泡排序算法和选择排序算法都更麻烦一些，但它也并不很复杂。它经常被用在较复杂的排序算法的最后阶段，例如快速排序。

插入排序原理即：局部有序，先把第一个数据看成一个有序数组，然后把第二个数据插入到这个“有序数组”中，形成具有两个数据的有序数组，依次类推，直至最后一个数据插入到具有 N-1 个数据的有序数组中，完成排序。插入过程：获取当前数据，并标记当前数据与下标，与之前有序数据的最后一个作比较，若小于最后一个数据则将最后一个数据进行后移操作，然后再与倒数第二个数据进行比较，重复刚才的操作，若不小于则终止操作。

3.2、代码实现

public class ArraySort {

public static void main(String[] args) {
int[] array = {1, 7, 3, 9, 8, 5, 4, 6};
array = sort(array);
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}

public static int[] sort(int[] array) {
for (int i = 1; i < array.length; i++) {
int temp = array[i];
int in = i;
while (in > 0 && array[in-1] >= temp) {
array[in] = array[in-1];
in--;
}
array[in] = temp;
}
return array;
}
}

3.3、效率

在第一趟排序中，它最多比较一次，第二趟最多比较两次，依此类推。最后一趟最多，比较 N-1 此。因此有

1+2+3+…+N-1=N*（N-1）/2

然而，因为在每一趟排序发现插入点之前，平均只有全体数据项的一半真的进行了比较，我们除以 2 得到 N*（N-1）/4

复制的次数大致等于比较的次数。然而，一次复制与一次交换的时间耗费不同，所以相对于随机数据，这个算法比冒泡排序快一倍，比选择排序略快。

对于随机顺序的数据进行插入排序也需要O（N2）的时间级。

对于已经有序或者基本有序的数据来说，插入排序要好得多。当数据有序的时候，while 循环的条件总是假的，所以它变成了外层循环中的一个简单语句，执行 N-1 次。在这种情况下，算法运行只需要 O（N）的时间。如果数据基本有序，插入排序几乎只需要 O（N）的时间，这对把一个基本有序的文件进行排序是一个简单而有效的方法。

然而，对于逆序排列的数据，每次比较和移动都会执行，所以插入排序不比冒泡排序快。

4、三种简单排序之间的比较

除非手边没有算法可以参考，一般情况几乎不太使用冒泡排序算法。它过于简单了，以至于可以毫不费力地写出来。然而当数据量很小的时候它会有些应用的价值。

选择排序虽然把交换次数降到了最低，但比较的次数仍然很大。当数据量很小，并且交换数据相对于比较数据更加耗时的情况下，可以应用选择排序。

在大多情况下，假设当数据量比较小或者基本上有序时，插入排序算法是三种简单排序算法中最好的选择。对于更大数据量的排序来说，快速排序通常是最快的方法：之后会有介绍。