插入排序的递归和迭代实现(范型)

插入排序

package edu.cumt.jnotnull;

public class InsertOrder {
	public static <T extends Comparable<? super T>> void insertionSort(T[] a,
			int first, int last) {
		for (int unsortedIndex = first + 1; unsortedIndex < last; unsortedIndex++) {
			T firstUnsorted = a[unsortedIndex];
			insertInOrder(firstUnsorted, a, first, unsortedIndex - 1);
		}
	}

	private static <T extends Comparable<? super T>> void insertInOrder(//将firstUnsorted插入到从a[begin]到a[end]的有序数组之间
			T firstUnsorted, T[] a, int begin, int end) {
		int index = end;
		while ((index >= begin) && (firstUnsorted.compareTo(a[index]) < 0)) {
			a[index + 1] = a[index];
			index--;
		}
		a[index + 1] = firstUnsorted;
	}
	
	//递归
	public static <T extends Comparable<? super T>> void insertionSortRec(T[] a,
			int first, int last) {
		if(first < last) {
			insertionSortRec(a,first,last-1);//对除最后一个元素外的所有元素排序
			insertInOrderRec(a[last],a,first,last-1);//将最后一个元素有序的插入
		}
	}
	
	private static <T extends Comparable<? super T>> void insertInOrderRec(T element,T[] a,
			int begin, int end){
		if(element.compareTo(a[end])>0){
			a[end+1] = element;
		}
		else if(begin < end){
			a[end +1] = a[end];
			insertInOrderRec(element,a,begin,end-1);
		}
		else{
			a[end+1] = a[end];
			a[end] = element;
		}
	}

}

 效率分析

 

    对于迭代算法insertionSort:对于一个有n个元素的数组,first为0,而last为n-1.for循环执行了n-1次,所以方法insertInOrder被执行了n-1次.

    而在insertInOrder中 begin为0,而end的范围从0到n-2.每次调用insertInOrder时,insertInOrder中的学范执行了end - begin+1次,因此循环执行了1+2+...(n-1)=n(n-1)/2  .即O(n^2)

 

    上面分析的时最坏的情况,在最好的情况下,在最好的情况下,insertInOrder中的循环将立即推出,这就是数组有序的情况.效率为O(n).越有序,时间越少...