数据结构及算法学习----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)。目前为止我们看到的三种排序算法，时间复杂度都是一样的，但是由于需要的交换次数和空间大小不同，因此实际过程中我们应该有选择性的去使用。