数据结构学习笔记（3）之算法

1 算法与数据结构的关系

只谈数据结构，固然可以，但在很短时间里学习完几种重要的数据结构，并不会完全掌握。但是如果把相应的算法也学一学，就会发现，算法使很多看似很难解决或者没法解决的问题，变得如此美妙和神奇。

2 两种算法比较

int i,sum=0,n=100;
for(i=1;i<=n;i++){
	sum=sum+1;
}
printf("%d",sum);

int sum=0,n=100;
sum=(1+n)*n/2;
printf("%d",sum);

3 算法概念

3.1 定义

算法是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作。

3.2 算法特性

• 算法有零个或多个输入
• 算法至少有一个或多个输出

特性：

1. 有穷性
   指算法在执行有限步骤之后，自动结束而不会出现无限循环，并且每一个步骤在可接受的时间内完成。
2. 确定性
   算法的每一步骤都有确定含义，不会出现二义性。
3. 可行性
   算法的每一步都必须是可行的，也就是说，每一步都能够通过执行有限次数完成。

4 算法设计要求

• 正确性
  算法的正确性是指算法至少应该具有输入、输出和加工处理无歧义性、能正确反映问题的需求，能够得到问题的正确答案。
• 可读性
  算法设计的另一目的是为了便于阅读、理解和交流。
• 健壮性
  当输入数据不合法时，算法也能做出相关处理，而不是产生异常或出现莫名其妙的结果。
• 时间效率高和存储量低
  算法设计应该尽量满足时间效率高并且存储量低的要求。

5 算法效率度量方式

5.1 事后统计方法

这种方法主要通过设计好的测试程序和数据，利用计算机计时器对不同算法编制的程序的运行时间进行比较，从而确定算法效率高低。
很多缺陷：

• 必须依据实现编制好的程序，需要花费大量的时间和精力。
• 时间的比较需要依赖计算机硬件和软件等环境因素，有时这种影响甚至会覆盖算法本身的优劣。
• 算法的测试数据设计困难，而且要想比较两种算法，还需要一定规模的测试数据，数据少的话很难判断问题。
  考虑到这么多的问题和缺陷，我们就不予考虑事后统计的方法。

5.2 事前分析估算方法

在计算机程序编制前，依据统计方法对算法进行评估
一个高级程序语言编写的程序在计算机上运行时所消耗的时间取决于以下因素：

• 算法采用的策略、方法——算法好坏的根本
• 编译产生的代码质量——软件支持
• 问题的输入规模
• 机器执行指令的速度——硬件性能
  因此：一个程序的运行时间，依赖于算法的好坏和问题的输入规模。 所谓问题的输入规模是指输入量的多少。
  两种求和算法：

int i,sum=0,n=100;	//执行1次
for(i=1;i<=n;i++){	//执行n+1次
	sum=sum+1;		//执行n次
}
printf("%d",sum);	//执行1次

int sum=0,n=100;	//执行1次
sum=(1+n)*n/2;		//执行1次
printf("%d",sum);	//执行1次

最终在分析程序的运行时间时，最重要的是把程序看成是独立于程序设计语言的算法或者一系列步骤。

6 时间复杂度

6.1 函数的渐进增长

函数渐进增长：给定两个函数f(n)和g(n)，如果存在一个整数N，使得对于所有的n>N，f(n)总是比g(n)大，那么，我们说f(n)的增长渐进快于g(n)。

• 与最高次项相乘的常数并不重要。
• 最高次项指数大的，函数随着n的增长，结果也会变得增长特别快
• 判断一个算法效率时，函数中的常数和其他次要项常常可以忽略，而更应该关注主项（最高阶项）的阶数。
  结论：
  某个算法，随着n的增大，它会越来越优于另一种算法，或者越来越差与另一种算法。

6.2 算法时间复杂度

定义：
在进行算法分析时，语句总的执行次数T(n)是关于问题规模n的函数，进而分析T(n)随n的变化情况并确定T(n)的数量级，算法的时间复杂度，也就是算法的时间度量，记做：T(n)=O(f(n))。它表示随问题规模n的增大，算法执行时间的增长率和的增长率相同，称作算法的渐进时间复杂度，简称时间复杂度。其中f(n)是问题规模n的某个函数
推导大O阶：

• 用常数1取代运行时间中的所有加法常数
• 在修改后的运行次数函数中，只保留最高阶项
• 如果最高阶项存在且不是1，则去除与这个项相乘的常数。
  以上步骤得到的结果就是大O阶

1.常数阶：所有常数阶都是O(1)
2.线性阶：分析算法的复杂度，关键是要分析循环语句的运行情况
3.对数阶：

int count=1;
while(count<n){
	count=count*2;
}
printf("%d",count);

上述程序count每次*2之后就距离n更近了。也就是说，有多少个2相乘后大于n，则就会退出循环。由2^x=n，得x=log2(n)，所以这个循环的时间复杂度为O(logn)。
4.平方阶：
例1

int i,j;
for(i=0;i<n;i++){
	for(j=0;j<n;j++){
		//O(1)语句
	}
}
上述程序时间复杂度为O(n^2)

例2

int i,j;
for(i=0;i<m;i++){
	for(j=0;j<n;j++){
		//O(1)语句
	}
}
上述程序时间复杂度为O(m*n)

例3

int i,j;
for(i=0;i<n;i++){
	for(j=i;j<n;j++){
		//O(1)语句
	}
}
上述程序 j<i 而不是 j<0 ，
执行次数为：n+(n-1)+(n-2)+(n-3)+......+1=n(n+1)/2=n^2/2+n/2，
由大O阶推导方式得出：时间复杂度为O(n^2)

理解大O推导并不难，难的是对数列的一些相关运算，更多的考察的是数学知识和能力
例4

方法调用的时间复杂度分析
int i,j;
for(i=0;i<m;i++){
	function(i);
}
void function(int count){
	print(count);
}
function函数的时间复杂度为O(n)
所以上述程序时间复杂度为O(n)

若function函数如下：
void function(int count){
	int j;
	for(j=count;j<n;j++){
		//O(1)
	}
}
只不过是把嵌套放进函数里
实际上上述程序像其他嵌套一样，时间复杂度还为O(n^2)

例5

相对复杂些的程序
n++;
function(n);
int i,j;
for(i=0;i<m;i++){
	function(i);
}
for(i=0;i<n;i++){
	for(j=0;j<n;j++){
		//O(1)
	}
}
void function(int count){
	print(count);
}
执行次数：f(n)=1+n+n^2+n(n+1)/2=(3n^2)/2+3n/2+1
所以上述程序时间复杂度为O(n^2)

常见的时间复杂度：

执行次数函数	阶	非正式用语
12	O(1)	常数阶
2n+3	O(n)	线性阶
3n2+2n+1	O(n2)	平方阶
5log2n+20	O(logn)	对数阶
2n+3nlog2n+19	O(nlogn)	nlogn阶
6n32n2+3n+4	O(n3)	立方阶
2n	O(2n)	指数阶

常用时间复杂度所耗费的时间从小到大依次是：
O(1)2)3)n)n)

6.3 最坏情况和平均时间

最坏情况运行时间是一种保证，那就是运行时间将不会再长了。在应用中，这是一种最重要的需求，通常除非特别指定，我们提到的运行时间都是最坏情况的运行时间。
平均运行时间是所以情况中最有意义的，因为它是期待的运行时间

6.4 算法空间复杂度

算法空间复杂度通过计算算法所需的存储空间实现，算法空间复杂度的计算公式记做：S(n)=O(f(n))，其中n是问题规模，f(n)为语句关于n所占存储空间的函数。
OVER，哈哈这章真长…