算法导论 第二章算法基础（2）插入排序算法的分析

插入排序算法的分析

Insertion-Sort需要的时间依赖于输入规模和被排序程度。输入规模的最佳概念依赖于研究的问题。对许多问题，如排序或计算离散傅里叶变化，最自然的量度是输入中的项数。再如两个整数相乘，输入规模的最佳量度是用通常二进制记号表示输入所需的总位数。有时，用两个数而不是一个数来描述输入规模更合适，如某个算法输入的是一个图，则输入规模可以用该图中的顶点数和边数来描述。

一个算法在特定输入上的运行时间是值执行的基本操作或步数。首先给出Insertion-Sort中，每条语句的执行时间和执行次数。对$j=2,3,\cdots ,n,$ 其中$n=A.length$，假设$t_j$表示对那个值$j$第4行执行while循环测试的次数，当一个for或while循环按通常的方式（即由于循环头中的测试）退出时，执行测试的次数比执行循环提的次数多1。

for j = 2 to A.length
    key = A[j]
    i = j - 1
    while(i > 0 and A[i] > key)
        A[i + 1] = A[i]
        i = i - 1
    A[i + 1] = key

Insertion-Sort	代价	次数
for j = 2 to A.length	$c_1$	$n$
key = A[j]	$c_2$	$n-1$
i = j - 1	$c_3$	$n-1$
while(i > 0 and A[i] > key)	$c_4$	$\sum _{j=2}^n{t}_j$
A[i + 1] = A[i]	$c_5$	$\sum _{j=2}^n(t_j-1)$
i = i - 1	$c_6$	$\sum _{j=2}^n(t_j-1)$
A[i + 1] = key	$c_7$	$n-1$

为计算在具有$n$个值的输入上Insertion-Srot的运行时间$T(n)$，我们将代价和次数对应元素之积求和，得：
$$T(n)=c_{1}n+c_2(n-1)+c_3(n-1)+c_4\sum _{j=2}^n{t}_j+c_5\sum _{j=2}^n(t_j-1)+c_6\sum _{j=2}^n(t_j-1)+c_7(n-1)$$

• 最佳运行时间：当输入数组已经排序时，对于每个$j=2, 3,\cdots, n, $我们发现在第4行，当$i$取初值$i-1$时，有$A[i]\le key$，则出现最佳情况。运行时间为：
  $$\begin{gathered} T(n)=c_{1}n+c_2(n-1)+c_3(n-1)+c_4(n-1)+c_7(n-1) \\ =(c_1+c_2+c_3+c_4+c_7)n-(c_2+c_3+c_4+c_7) \end{gathered}$$

我们把该运行时间表示为$an+b$,其中常量$a$和$b$依赖于语句代价$c_i$。因此，它是$n$的线性函数。

• 最坏运行时间：当输入的数组为反序时，对于每个$j=2,3,\cdots ,n,$,有$t_j=j$。
  $$\sum _{j=2}^{n}j=\frac{n(n+1)}{2}-1$$

和

$$\sum _{j=2}^n(j-1)=\frac{n(n-1)}{2}$$

则运行时间为：
$$\begin{gathered} T(n)=c_{1}n+c_2(n-1)+c_3(n-1)+c_4(\frac{n(n+1)}{2}-1)+c_5(\frac{n(n-1)}{2})+c_6(\frac{n(n-1)}{2})+c_7(n-1) \\ =\frac{1}{2}(c_4+c_5+c_6)n^2+(c_1+c_2+c_3+\frac{c_4}{2}-\frac{c_5}{2}-\frac{c_6}{2}+c_7)n-(c_2+c_3+c_4+c_7) \end{gathered}$$

我们把该运行时间表示为$a{n}^2+bn+c$，其中常量$a$、$b$和$c$依赖于语句代价$c_i$，它是$n$的二次函数。

最坏情况和平均情况分析

最坏情况运行时间的重要性：

• 一个算法的最坏情况运行时间给出了任何输入的运行时间的一个上界。
• 对某些算法，最坏情况经常出现。
• 平均情况往往与最坏情况一样差。

增长量级

我们使用简化抽象使Insertion-Sort的分析更加容易。首先，通过使用常量$c_i$表示这些代价来忽略每条语句的实际代价。其次，注意到这些常量也提供了比我们真正需要的要多的细节：把最坏情况运行时间表示为$a{n}^2+bn+c$，其中常量$a$、$b$和$c$依赖于语句代价$c_i$。

现在，我们关注算法运行时间的增长率或增长量级，所以我们只考虑公式中最高阶项，因为当$n$的值很大时，低阶项相对来说不太重要，同时也忽略最高阶项的常系数。我们记插入排序的最坏运行时间为$\theta (n^2)$。

如果一个算法的最坏情况运行时间具有比另一个算法更低的增长量级，那么我们通常认为前者比后者更有效。

练习

2.2-1

$$\theta (n^3)=\theta (\frac{n^3}{1000}-100n^2-100n+3)$$

2.2-2

循环不变式 ：对于每次循环，子数组中（已选择的元素）已排序。
初始化 ：在第一次循环前$j=1$时，子数组中不包含元素，故是已排序的。
保持 ：从$A[j]\cdots A[n]$中选出最小数与$A[j]$交换，因此$A[1]\le A[2]\le \cdots \le A[j-1]\le A[j]$。循环不变式保持。
结束 ：当$j=n-1$ 时，$A[n-1]$必然小于$A[n]$(由保持可得)，故$A[0]\cdots A[n]$都是有序的。算法成立

• 对前n-1数排序
  由保持的性质可值，当$j=n-1$ 时 从$A[n-1]$和$A[n]$ 中选出最小数和$A[n-1]$ 交换， 因此 $A[n-1]\le A[n]$。故不需要对前n-1数执行即可。

• 最好情况和最坏情况
  最好：$\theta (n^2)$ 最坏：$\theta (n^2)$

# -*- coding:utf-8 -*-
import sys
import random

def  findMin(array):
	_min, index = sys.maxsize, 0
	for j in  range(len(array)):
		if _min > array[j]:
			_min, index = array[j], j

	return _min, index

def  selectSort(array):
	for i in  range(0, len(array) -  1):
		_min, index = findMin(array[i:])
		array[index + i], array[i] = array[i], array[index + i]

if __name__ ==  "__main__":
	array = random.sample([x for x in  range(100)], 20)
	print("Before Select Sort:",array)
	selectSort(array)
	print("End Select Sort:",array)

2.2-3

• 平均情况 要检查$\frac{n+1}{2}$个元素，运行时间$\theta (n)$
  由于假定要查找的元素等可能为数组中的任意元素，所以每次查找得到结果的概率为:$P(A)=\frac{1}{n}$。假设进行n次实验，数组长度均为m，每次实验可以视为独立事件，则在数组$A_n$ 中查找得到结果得概率为$P(A_i)=\frac{i}{m}$。则n次实验得总概率为根据概率的有限可加性可得：
  $$\begin{gathered} P(A_1\cup A_2\cup \cdots \cup A_n)=P(A_1)+P(A_2)+\cdots +P(A_n) \\ =\frac{1}{n}+\frac{2}{n}+\cdots +\frac{n}{n} \\ =\frac{1}{2}(n+1) \end{gathered}$$

• 最坏情况 要检查$n$个元素，运行时间$\theta (n)$

2.2-4

测试边界情况和最坏情况，尽可能的在每一步中使用$\theta (n)$小的操作。