代码实现：
public void insertionSort(List<T> list, Comparator<T> comparator) {
for (int i=1; i<list.size(); i++) {
T elt_i = list.get(i);
int j = i;
while (j>0) {
T elt_j = list.get(j-1);
if (comparator.compare(elt_i,elt_j)>=0) {
break;
}
list.set(j,elt_j);
j--;
}
list.set(j,elt_i);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
测试：
List<Integer> list = new ArrayList<Integer>(Arrays.asList(3, 5, 1, 4, 2));
Comparator<Integer> comparator = new Comparator<Integer>() {
@Override
public int compare(Integer elt1, Integer elt2) {
return elt1.compareTo(elt2);
}
};
ListSorter<Integer> sorter = new ListSorter<Integer>();
sorter.insertionSort(list, comparator);
System.out.println(list);
1
2
3
4
5
6
7
8
9
10
11
12
insertionSort有两个嵌套循环，所以你可能会猜到，它的运行时间是二次的。在这种情况下，一般是正确的，但你做出这个结论之前，你必须检查，每个循环的运行次数与n，数组的大小成正比。
外部循环从1迭代到list.size()，因此对于列表的大小n是线性的。内循环从i迭代到0，所以在n中也是线性的。因此，两个循环运行的总次数是二次的。
如果你不确定，这里是证明：
第一次循环中，i = 1，内循环最多运行一次。 第二次，i = 2，内循环最多运行两次。 最后一次，i = n - 1，内循环最多运行n次。
因此，内循环运行的总次数是序列1, 2, ..., n - 1的和，即n(n - 1)/2。该表达式的主项（拥有最高指数）为n^2。
在最坏的情况下，插入排序是二次的。然而：
如果这些元素已经有序，或者几乎这样，插入排序是线性的。具体来说，如果每个元素距离它的有序位置不超过k个元素，则内部循环不会运行超过k次，并且总运行时间是O(kn)。
由于实现简单，开销较低；也就是，尽管运行时间是an^2，主项的系数a，也可能是小的。
所以如果我们知道数组几乎是有序的，或者不是很大，插入排序可能是一个不错的选择。
---------------------