数据结构及算法学习----03----插入排序

前沿：

如果需要了解简单排序中的冒泡排序和选择排序，请查看一下连接：

冒泡排序 点击这里

选择排序 点击这里

介绍：

在大多数情况下，插入排序算法是基本排序算法中最好的一种。虽然插入排序算法仍然需要O(N*N)的时间，但是在一般情况下，要比冒泡排序快一倍，甚至比选择排序还快一些。然而，并不是什么情况下插入排序算法的效率都是最好的。比如一个极端的情况：对于逆序排列的数据，每次比较和移动都会执行，所以插入排序不必冒泡排序快。因此，在选择这些算法的时候，要根据实际情况酌情处理才是上策。

思路：
把N个待排序的数据项看成一个有序部分和一个无序部分。开始的时候有序部分只有一个数据项(亦即第一个数据项，数组中下标为0的位置)，无序部分中有N-1个数据项(除开数组中第一个数据项之外的其他数据项)。排序过程中每次从无序部分取出第一个元素，在有序部分中找到合适的位置将这个新取出的数据项放在该处，使之成为有序部分的一个数据项。经过这一次之后，有序部分多了一个数据项而无序部分少了一个数据项，以此类推，就可以实现序列的有序性。

核心代码：

public void insertSort() {
int innerLoop,outterLoop;
for(outterLoop=1;outterLoop<elementCount;outterLoop++) {
double temp  = array[outterLoop];
innerLoop = outterLoop;
while(innerLoop>0 && array[innerLoop-1]>=temp) {
array[innerLoop] = array[innerLoop-1];
innerLoop--;
}//end of while
array[innerLoop] = temp;
}//end of for
}//end of method insertSort()

核心代码说明：

外层的for循环中，outterLoop变量从1开始，向右移动。这是因为已经假设第一个数组就是有序的部分了。内层的while循环中，innerLoop变量从outterLoop变量开始，向左移动，直到temp变量小于innerLoop所指的数据项，或者它已经不能再往左移动为止。while循环中的每一趟都向右移动了一个已排序的数据项。

完整代码：

package barry.sort.insertsort;

public class InsertSorter {

private double[] array;
private int elementCount;

public InsertSorter(int size) {
array = new double[size];
elementCount = 0;
}// end of constructor

public void insert(double value) {
array[elementCount++] = value;
}// end of method insert()

public void display() {
for (int i = 0; i < elementCount; i++) {
System.out.print(array[i] + "\t");
}// end of for
}// end of method display()

public void insertSort() {
int innerLoop,outterLoop;
for(outterLoop=1;outterLoop<elementCount;outterLoop++) {
double temp  = array[outterLoop];
innerLoop = outterLoop;
while(innerLoop>0 && array[innerLoop-1]>=temp) {
array[innerLoop] = array[innerLoop-1];
innerLoop--;
}//end of while
array[innerLoop] = temp;
}//end of for
}//end of method insertSort()

}// end of class

package barry.sort.insertsort;

public class InsertSorterApp {
public static void main(String[] args) {

InsertSorter sorter = new InsertSorter(10);
sorter.insert(-10);sorter.insert(56);
sorter.insert(23);sorter.insert(8723);
sorter.insert(-90);sorter.insert(993);
sorter.insert(33);sorter.insert(-373);

//display them before sort
System.out.println("\nBefore Sort:");
sorter.display();

//sort them
sorter.insertSort();

//display tem after sort
System.out.println("\nAfter Sort:");
sorter.display();
}//end of main
}//end of class

运行结果：

Before Sort:
-10.0	56.0	23.0	8723.0	-90.0	993.0	33.0	-373.0
After Sort:
-373.0	-90.0	-10.0	23.0	33.0	56.0	993.0	8723.0

总结：

以上的过程我们发现插入排序很简单，但是效率如何呢？首先从空间来看，它只需要一个元素的辅助空间，用于元素的位置交换。从时间分析，首先外层循环要进行n-1次插入，每次插入最少比较一次（正序），移动两次；最多比较i次，移动i＋2次（逆序）（i=1，2，…，n-1）。因此，插入排序的时间复杂度为O(N*N)。目前为止我们看到的三种排序算法，时间复杂度都是一样的，但是由于需要的交换次数和空间大小不同，因此实际过程中我们应该有选择性的去使用。