Java排序算法（六）：直接插入排序

Java排序算法（六）：直接插入排序

直接插入排序的基本操作就是将待排序的数据元素按其关键字值的大小插入到前面的有序序列中。

直接插入的时间效率并不高，如果在最坏的情况下，所有元素的比较次数总和为（0+1+...+n-1）=O(n^2)。其他情况下也要考虑移动元素的次数，故时间复杂度为O(n^2)

直接插入空间效率很好，只需要1个缓存数据单元，也就是说空间复杂度为O(1).

直接插入排序是稳定的。

直接插入排序在数据已有一定顺序的情况下，效率较好。但如果数据无规则，则需要移动大量的数据，其效率就与冒泡排序法和选择排序法一样差了。

算法描述

对一个有n个元素的数据序列，排序需要进行n-1趟插入操作：

第1趟插入，将第2个元素插入前面的有序子序列--此时前面只有一个元素，当然是有序的。

第2趟插入，将第3个元素插入前面的有序子序列，前面2个元素是有序的。

第n-1趟插入，将第n个元素插入前面的有序子序列，前面n-1个元素是有序的。

 

代码实现

[java] view plaincopyprint?

1. package sort;  
2.   
3. public class InsertSortTest {  
4.     public static int count = 0;  
5.   
6.     public static void main(String[] args) {  
7.   
8.         int[] data = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 };  
9.         print(data);  
10.         insertSort(data);  
11.         print(data);  
12.   
13.     }  
14.   
15.     public static void insertSort(int[] data) {  
16.         for (int i = 1; i < data.length; i++) {  
17.             // 缓存i处的元素值  
18.             int tmp = data[i];  
19.             if (data[i] < data[i - 1]) {  
20.                 int j = i - 1;  
21.                 // 整体后移一格  
22.                 while (j >= 0 && data[j] > tmp) {  
23.                     data[j + 1] = data[j];  
24.                     j--;  
25.                 }  
26.                 // 最后将tmp插入合适的位置  
27.                 data[j + 1] = tmp;  
28.                 print(data);  
29.             }  
30.         }  
31.     }  
32.   
33.     public static void print(int[] data) {  
34.         for (int i = 0; i < data.length; i++) {  
35.             System.out.print(data[i] + "\t");  
36.         }  
37.         System.out.println();  
38.     }  
39.   
40. }  

运行结果：

[java] view plaincopyprint?

1. 5   3   6   2   1   9   4   8   7     
2. 3   5   6   2   1   9   4   8   7     
3. 2   3   5   6   1   9   4   8   7     
4. 1   2   3   5   6   9   4   8   7     
5. 1   2   3   4   5   6   9   8   7     
6. 1   2   3   4   5   6   8   9   7     
7. 1   2   3   4   5   6   7   8   9     
8. 1   2   3   4   5   6   7   8   9