算法导论第2章(1)：插入排序,算法分析

排序基类

public abstract class Sort
{
	public static final int  INCREMENT = 0; //升序
	public static final int  DECREMENT = 0; //降序
	
	/**
	 * 排序过程
	 * @param s 带排数列
	 * @param incOrDec 控制升序还是降序
	 * @return
	 */
	public int [] sort(int [] s, int incOrDec){return null;};
	
	/**
	 * 打印 一个数列
	 * @param s
	 */
	public void print(int [] s)
	{
		if(s == null) { System.out.println("s == null"); return; }
		for(int i:s)
			System.out.print(i +" ");
	}
}

 

插入排序 insert-sort

对数列A进行排序

伪代码：

1	for j <- 2 to  length(A)
2	do key <-A[j]
3	// 把A[j]插入到已经排好序的数列A[1...j-1]中
4	i <- j-1;
5	//已经排好序的数列A[1...j-1]中中，找到第一个比key小的元素的位置
6	while i>0 and A[i] > key
7	do A[i+1]<-A[i]
8	i <- i-1
9	A[i+1] = key;

 

下面是一个例子的排序过程：

 

java 实现插入排序

 

/**
 * 
 * @author buptjunjun
 * @time 2013-1-22
 *
 */
public class InsertSort extends Sort
{	
	/**
	 * 插入排序
	 * @param s 带排数列
	 * @param incOrDec 控制升序还是降序
	 * @return
	 */
	@Override
	 public int[] sort(int[] s,int incOrDec)
	 {
		if(s == null || s.length <=1) return s;	
		for(int i = 1;i <s.length; i++)
		{
			int key = s[i];
			int j = i-1;
			//下面将key插入到已经排好的数列中去
			if(incOrDec == Sort.INCREMENT) //升序
			{	
				while(j>=0 && key<s[j]){ s[j+1] = s[j]; j--;}
			}
			else if(incOrDec == Sort.DECREMENT) //降序
			{
				while(j>=0 && key>s[j]){ s[j+1] = s[j]; j--;}
			}
			s[j+1] = key;
		}		
		return s;
	}
	/**
	 * @param args
	 */
	public static void main(String[] args)
	{
		int [] s = {2,5,3,1,1,3,4,4,9,0};
		int [] ret = new InsertSort().sort(s,Sort.INCREMENT);		
		new InsertSort().print(s);
	}

}

如何证明算法是正确的(归纳法)

要证明一个算法是正确的，分２步：

１、在第一轮迭代之前是正确的

２、在循环的某一次迭代开始之前是正确的，在下一次开始之前是正确的。

其实这就是一个数学归纳法的应用

 

算法分析

Num	算法	Cost	T
1	for j <- 2 to  length(A)	C1	n
2	do key <-A[j]	C2	n-1
3	// 把A[j]插入到已经排好序的数列A[1...j-1]中	0	n-1
4	i <- j-1;	C3	n-1
5	//已经排好序的数列A[1...j-1]中中，找到第一个比key小的元素的位置	0	n-1
6	while i>0 and A[i] > key	C4
7	do A[i+1]<-A[i]	C5
8	i <- i-1	C6
9	A[i+1] = key;	C7	n-1

 

其中C_i是第j个语句的所用时间，T_j是j个语句执行的次数

 

总时间就是：

T = n*C1 + (n-1)*C2+ (n-1)*C3+ ()*C4 + () *C5+ () *C6+(n-1)*C7

现在要确定的是t_j 

当数组已经是排好序的那么t_j= 1

T = n*C1 + (n-1)*C2+ (n-1)*C3+ (n-1)*C4+ +(n-1)*C7

  = (C1+C2+C3+C4+C7)n -(C2+C3+C4+C7) = a*n+b

 

可见当值排好序的情况下 T是n的线性函数

 

当数组已经是按逆序排好序的那么t_j= j

T  = n*C1 + (n-1)*C2+ (n-1)*C3+ ()*C4 + () *C5+ () *C6+(n-1)*C7

=a*n²+b*n+c

可见 T是关于n的二次函数

 

函数增长量级：

在前面分析中，我们忽略了每条语句的真实代价，使用a b c来代替，他们是依赖于Cj的。可以再做抽象，我们取最高次项，忽略了低次项目，因为当n很大的时候低次项是不重要的。

可以进一步抽象去掉最高次项的系数，因为因为当n很大的时候，系数对增长率的贡献很小。

这样可以这样表示插入排序的最坏时间代价为