算法描述：

从一个无序的集合中取出一个元素，插入到一个有序的集合的合适位置，有序的集合插入新元素之后，仍然是有序的。所以该算法最核心的部分是要在有序集合中找到合适的插入位置。

Java代码：

package ljp.sort.insert; public class InsertSortDemo01 { private int[] list; public InsertSortDemo01(int[] list){ this.list = list; } public void sort(){ int count = 0;//排序次数 for(int i = 1;i<list.length;i++){ for(int j = 0;j<i;j++){ if(list[i]<list[j]){ int temp = list[i]; for(int k = i;k>j;k--){ list[k] = list[k-1]; } list[j] = temp; } } System.out.println("第"+ ++count +"次排序："); display(); } } public void display(){ for(int i:list){ System.out.print(i+" "); } System.out.println(); } public static void main(String[] args) { int[] list = new int[10]; for(int i = 0;i<list.length;i++){ list[i] = (int) (Math.random()*1000); } InsertSortDemo01 sort = new InsertSortDemo01(list); System.out.println("排序前："); sort.display(); sort.sort(); } }

运行结果：

排序前：
300 748 262 274 284 263 135 283 388 477
第1次排序：
300 748 262 274 284 263 135 283 388 477
第2次排序：
262 300 748 274 284 263 135 283 388 477
第3次排序：
262 274 300 748 284 263 135 283 388 477
第4次排序：
262 274 284 300 748 263 135 283 388 477
第5次排序：
262 263 274 284 300 748 135 283 388 477
第6次排序：
135 262 263 274 284 300 748 283 388 477
第7次排序：
135 262 263 274 283 284 300 748 388 477
第8次排序：
135 262 263 274 283 284 300 388 748 477
第9次排序：
135 262 263 274 283 284 300 388 477 748

算法分析：

在最坏的情况下，内层循环的次数为i才可以找到合适的插入位置，每一次排序，对于一个元素为n的集合，都需要循环n-1次，所以

T(n) = 1 + 2 + ······ + n-1 = O(n^2)

最好的情况下，内层循环的次数为0次就可以找到合适的插入位置，所以总循环次数（不算插入操作时以为的循环）为

T(n) = 1 + 1 + ······ + 1 = n-1 = O(n)

在平均情况下，插入位置随机出现，假设出现的概率相等，这样子内层循环的次数平均为i/2。所以排序总循环次数（不算插入操作时以为的循环）为

T(n) = 1/2 + 2/2 + ······ + (n-1)/2 = (n-1)n/4 = O(n^2)

所以该算法的时间复杂度为O(n^2)。

原地排序：原地排序是指排序过程中不使用临时空间，即排序前和排序后元素都在同一地方的排序。

根据原地排序的定义，插入排序也是一种原地排序。

排序算法稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，ri=rj，且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。

从排序算法稳定性的概念来看，插入排序算法是稳定的。