数据结构与算法day15-排序算法介绍与算法的性能分析(时间复杂度和时间频度)

排序算法的介绍
	排序也称排序算法(Sort Algorithm)，排序是将一组数据，
	依指定的顺序进行排列的过程。
排序的分类：
	1.内部排序：
		指将需要处理的所有数据都加载到内部存储器中进行排序
	2.外部排序法：
		数据量过大，无法全部加载到内存中，需要借助外部存储进行排序
	3.常见的排序算法分类
		内部排序：
			插入排序：直接插入排序、希尔排序
			选择排序：简单选择排序、堆排序
			交换排序：冒泡排序、快速排序
			归并排序：
			基数排序：
		外部排序：

算法的时间复杂度(涉及高数知识)：
	度量一个程序执行时间的两种方法
		1.事后统计法：
			这种方法可行，但是有两个问题：一是要想对设计的算法的运行性能
			进行评估，需要实际运行该程序；二是所得时间的统计量依赖于计算机
			的硬件、软件等环节因素，这种方式，要在同一台计算机的相同状态
			下运行，才能比较那个算法速度更快。
		2.事前估算法：
			通过分析某个算法的时间复杂度来判断哪个算法更优
	时间频度：
		一个算法花费的时间与算法中语句的执行次数成正比，哪个算法中
		语句执行次数多，它花费时间就多。一个算法中的语句执行次数称
		为语句频度或时间频度。记作T(n)

举例说明时间频度：
	比如计算1-100所有数字之和，我们设计两种算法：
		int total = 0;
		int end = 100;
		// 使用for循环计算
		for (int i = 1; i <= end; i++) {
			total += i;
		}
		时间频度：T(n) = n + 1;
		
		// 直接计算
		total = (1+end)*end/2;
		时间频度：T(n) = 1

	为什么要忽略常数项？
		因为当实验数据越来越大的时候，两个变量一样的表达式(常数项不一样)的
		结果会无限接近。
		结论：
			2n+20和2n随n变大，执行曲线无限接近，20可以忽略
			3n+10和3n随着n变大，执行曲线无限接近，10可以忽略
	为什么要忽略低次项？
		因为当实验数据越来越大的时候，两个变量一样的表达式(低次项不一样)的
		结果会无限接近。
		结论：
			2n^2+3n+10和2n^2随着n变大，执行曲线无限接近，可以忽略3n+10
			n^2+5n+20和n^2随着n变大，执行曲线无限接近，可以忽略5n+20
	为什么要忽略系数？
		n前面的系数可以忽略，但是次方不可以忽略
			1.随着程序规模 n 的增大，T(n) = 3n²+2n 与 T(n) = 5n²+7n 的执行曲线基本重合，
				系数 3 和 5 可以忽略不计。
			2.T(n) = n³+5n 与 T(n) = 6n³+4n 执行曲线分离，所以
				忽略系数不适用于 n^k(k>=3) 的情况。

时间复杂度：
	1.一般情况下，算法中的基本操作语句的重复执行次数是问题规模n的某个函数，
	用T(n)表示，若有某个辅助函数f(n)，使得当n趋向无穷大时，
	T(n)/f(n)的极限值为不等于0的常数，则称f(n)是T(n)的同数量级函数。
	记作T(n)=O(f(n))，称O(f(n))为算法的渐进时间复杂度，简称时间复杂度
	2.T(n)不同，但时间复杂度可能相同。如：T(n)=n^2+7n+6与
	T(n)=3n^2+2n+2它们的T(n)不同，但时间复杂度相同，都O(n^2)
	3.计算时间复杂度的方法：
		a.用常数1代替运行时间中的所有加法常数T(n)=n^2+7n+6--> T(n)=n^2+7n+1
		b.修改后的运行次数函数中，只保留最高阶项T(n)=n^2+7n+1--> T(n)=n^2
		c.去除最高阶项的系数T(n)=n^2--> O(n^2)

	常见的时间复杂度：
		1.常阶数O(1)
		2.对数阶O(log2n)
		3.线性阶O(n)
		4.线性对数阶O(nlog2n)
		5.平方阶O(n^2)
		6.立方阶O(n^3)
		7.K方阶O(n^k)
		8.指数阶O(2^n)

	说明：
		常见的算法时间复杂度由小到大依次为：O(1)<O(log2n)<O(n)<O(nlog2n)
			<o(n^2)<O(n^3)<O(n^k)<O(2^n)，随着问题规模n的不断增大，上述
			时间复杂度不断增大，算法的执行效率越低
		如下图，尽可能避免指数阶的算法，效率低

举例说明时间复杂度：
	1.常数阶O(1)：
		无论代码执行了多少行，只要是没有循环等复杂结构，那这个代码的时间
		复杂度就都是O(1)
			int i = 1;
			int j = 2;
			++i;
			j++;
			int m = i + j;
		上述代码在执行的时候，它消耗的时候并不随着某个变量的增长而增长，
		那么无论这类代码有多长，即使有几万几十万行，都可以用O(1)来
		表示它的时间复杂度。
		
	2.对数阶O(log2n)
			int i = 1;
			while (i<n) {
				i = i * 2;
			}
		说明：在while循环里，每次都将i乘以2，乘完以后，i距离n越来越近。
		假设循环X次后，i就大于n了，此时这个循环就退出了，也就是说2的
		x次方等于n，那么x=log2n也就是说当循环log2n次以后，这个代码就
		结束了。因此这个代码的时间复杂度为：O(log2n)
		O(log2n)的这个2时间上是根据代码变化的。i = i * 3则是O(log3n)
		
		如果N=a^x(a>0，a != 1)，那么数x叫做以a为底N的对数，记作x=logaN。
		其中a叫做对数的底数，N叫做真数，x叫做以a为底N的对数

	3.线性阶O(n)
			for (int i = 1; i <= n;  ++i) {
				j = i;
				j++;
			}
		说明：这段代码，for循环里面的代码会执行n遍，因此它消耗的时间是
		随着n的变化而变化的，因此这类代码都可以用O(n)树赖表示复杂度

	4.线性对数阶O(nlogN)
			for (m = 1; m < n; m++) {
				i = 1;
				while (i < n) {
					i = i * 2;
				}
			}
		说明：线性对数阶O(logN)其实非常容易理解，将时间复杂度O(logN)的代码
		循环N遍的话，那么它的时间复杂度就是n*O(logN)，也就是O(nlogN)
	
	5.平方阶O(n^2)
			for (x = 1; i <= n; x++) {
				for (i = 1; i <= n; i++) {
					j = i;
					j++;
				}
			}
		说明：平方阶O(n^2)更容易理解，即嵌套了两个时间复杂度为n的for循环。
		如果一个循环n次，一个循环m次，那么复杂度就是O(m*n)

	6.立方阶O(n^3)
		就是嵌套3层for循环
		

平均时间复杂度和最坏时间复杂度：
	1.平均时间复杂度是指所有可能的输入实例均以等概率出现的情况下，该算法
	的运行时间
	2.最坏情况下的时间复杂度称最坏时间复杂度。一般讨论的时间复杂度均是
	最坏情况下的时间复杂度。这样做的原因是：最坏情况下的时间复杂度是
	算法在任何输入实例上运行时间的界限，这就保证了算法的运行时间不会比
	最坏情况更长
	3.平均时间复杂度和最坏时间复杂度是否一致，和算法有关，如下图

算法的空间复杂度：
	基本介绍：
		1.类似于时间复杂度的讨论，一个算法的空间复杂度(Space Complexity)
		定义为该算法所消耗的存储空间，它也是问题规模n的函数。
		2.空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度。
		有的算法需要占用的临时工作单元数与解决问题的规模n有关，它随着
		n的增大而增大，当n较大时，将占用较多的存储单元，例如快速排序
		和归并排序算法就属于这种情况。
		3.在做算法分析时，主要讨论的是时间复杂度，从用户使用体验上看，
		更看重的程序执行速度。一些缓存产品(redis，memcache)和算法(基数排序)
		本质就是空间交换时间。