算法复杂度
求解算法的时间复杂度的具体步骤
求解算法的时间复杂度的具体步骤是：⑴ 找出算法中的基本语句；算法中执行次数最多的那条语句就是基本语句，通常是最内层循环的循环体。
⑵ 计算基本语句的执行次数的数量级；只需计算基本语句执行次数的数量级，这就意味着只要保证基本语句执行次数的函数中的最高次幂正确即可，可以忽略所有低次幂和最高次幂的系数。
这样能够简化算法分析，并且使注意力集中在最重要的一点上：增长率。
⑶ 用大Ο记号表示算法的时间性能。
将基本语句执行次数的数量级放入大Ο记号中。
如果算法中包含嵌套的循环，则基本语句通常是最内层的循环体，如果算法中包含并列的循环，则将并列循环的时间复杂度相加。
例如：for (i=1; i<=n; i++)x++;for (i=1; i<=n; i++)for (j=1; j<=n; j++)x++;第一个for循环的时间复杂度为Ο(n)，第二个for循环的时间复杂度为Ο(n2)，则整个算法的时间复杂度为Ο(n+n2)=Ο(n2)。
常见的算法时间复杂度由小到大依次为：Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(n3)＜…＜Ο(2n)＜Ο(n!)Ο(1)表示基本语句的执行次数是一个常数，一般来说，只要算法中不存在循环语句，其时间复杂度就是Ο(1)。
Ο(log2n)、Ο(n)、Ο(nlog2n)、Ο(n2)和Ο(n3)称为多项式时间，而Ο(2n)和Ο(n!)称为指数时间。
计算机科学家普遍认为前者是有效算法，把这类问题称为P类问题，而把后者称为NP问题。
O(1)Temp=i;i=j;j=temp;以上三条单个语句的频度均为1，该程序段的执行时间是一个与问题规模n无关的常数。
算法的时间复杂度为常数阶，记作T(n)=O(1)。
如果算法的执行时间不随着问题规模n的增加而增长，即使算法中有上千条语句，其执行时间也不过是一个较大的常数。
此类算法的时间复杂度是O(1)。
O(n^2)2.1. 交换i和j的内容sum=0；（一次）for(i=1;i<=n;i++) （n次）for(j=1;j<=n;j++) （n^2次）sum++；（n^2次）解：T(n)=2n^2+n+1 =O(n^2)2.2.for (i=1;i<n;i++){y=y+1; ①for (j=0;j<=(2*n);j++)x++; ②}解：语句1的频度是n-1语句2的频度是(n-1)*(2n+1)=2n^2-n-1f(n)=2n^2-n-1+(n-1)=2n^2-2该程序的时间复杂度T(n)=O(n^2). O(n)2.3.a=0;b=1; ①for (i=1;i<=n;i++) ②{s=a+b; ③b=a; ④a=s; ⑤}解：语句1的频度：2,语句2的频度： n,语句3的频度： n-1,语句4的频度：n-1,语句5的频度：n-1,T(n)=2+n+3(n-1)=4n-1=O(n).O(logn )2.4.i=1; ①while (i<=n)i=i*2; ②解：语句1的频度是1,设语句2的频度是f(n), 则：2^f(n)<=n;f(n)<=logn取最大值f(n)= logn,T(n)=O(logn )O(n^3)2.5.for(i=0;i<n;i++){for(j=0;j<i;j++){for(k=0;k<j;k++)x=x+2;}}解：当i=m, j=k的时候,内层循环的次数为k当i=m时, j 可以取 0,1,...,m-1 , 所以这里最内循环共进行了0+1+...+m-1=(m-1)m/2次所以,i从0取到n, 则循环共进行了: 0+(1-1)*1/2+...+(n-1)n/2=n(n+1)(n-1)/6所以时间复杂度为O(n^3).。
算法分类,时间复杂度,空间复杂度,优化算法
算法分类,时间复杂度,空间复杂度,优化算法算法 今天给⼤家带来⼀篇关于算法排序的分类,算法的时间复杂度,空间复杂度,还有怎么去优化算法的⽂章,喜欢的话,可以关注,有什么问题,可以评论区提问,可以与我私信,有什么好的意见,欢迎提出.前⾔: 算法的复杂度分为时间复杂度与空间复杂度,时间复杂度指执⾏算法需要需要的计算⼯作量,空间复杂度值执⾏算法需要的内存量,可能在运⾏⼀些⼩数据的时候,⼤家体会不到算法的时间与空间带来的体验. 优化算法就是将算法的时间优化到最快,将空间优化到最⼩,假如你写的mod能够将百度游览器的搜索时间提升0.5秒,那都是特别厉害的成绩.本章内容: 1,算法有哪些 2,时间复杂度,空间复杂度 3,优化算法 4,算法实例⼀,算法有哪些 常见的算法有冒泡排序,快排,归并,希尔,插⼊,⼆分法,选择排序,⼴度优先搜索,贪婪算法,这些都是新⼿⼊门必须要了解的,你可以不会,但是你必须要知道他是怎么做到的,原理是什么,今天就给⼤家讲⼀讲我们常⽤的冒泡排序,选择排序,这两个排序算法,1,冒泡排序(Bubble Sort), 为什么叫他冒泡排序呢? 因为他就像是从海底往海⾯升起的⽓泡⼀样,从⼩到⼤,将要排序的数从⼩到⼤排序,冒泡的原理: 他会⼀次⽐较两个数字,如果他们的顺序错误,就将其调换位置,如果排序正确的话,就⽐较下⼀个,然后重复的进⾏,直到⽐较完毕,这个算法的名字也是这样由来的,越⼤的数字,就会慢慢的'浮'到最顶端. 好了该上代码了,下⾯就是冒泡排序的代码,冒泡相对于其他的排序算法来说,⽐较的简单,⽐较好理解,运算起来也是⽐较迅速的,⽐较稳定,在⼯作中也会经常⽤到,推荐使⽤# 冒泡排序def bubble_sort(alist):n = len(alist)# 循环遍历，找到当前列表中最⼤的数值for i in range(n-1):# 遍历⽆序序列for j in range(n-1-i):# 判断当前节点是否⼤于后续节点，如果⼤于后续节点则对调if alist[j] > alist[j+1]:alist[j], alist[j+1] = alist[j+1], alist[j]if__name__ == '__main__':alist = [12,34,21,56,78,90,87,65,43,21]bubble_sort(alist)print(alist)# 最坏时间复杂度: O(n^2)# 最优时间复杂度: O(n)# # 算法稳定性:稳定2,选择排序(selection sort) 选择排序(selection sort)是⼀种简单直观的排序⽅法, 他的原理是在要排序的数列中找到最⼤或者最⼩的元素,放在列表的起始位置,然后从其他⾥找到第⼆⼤,然后第三⼤,依次排序,依次类,直到排完, 选择排序的优点是数据移动, 在排序中,每个元素交换时,⾄少有⼀个元素移动,因此N个元素进⾏排序,就会移动 1--N 次,在所有依靠移动元素来排序的算法中,选择排序是⽐较优秀的⼀种选择排序时间复杂度与稳定性:最优时间复杂度: O(n2)最坏时间复杂度:O(n2)算法稳定性 :不稳定(考虑每次升序选择最⼤的时候)# if alist[j] < alist[min_index]:# min_index = j## # 判断min_index索引是否相同,不相同，做数值交换# if i != min_index:# alist[i],alist[min_index] = alist[min_index],alist[i]### if __name__ == '__main__':# alist = [12,34,56,78,90,87,65,43,21]# # alist = [1,2,3,4,5,6,7,8,9]# select_sort(alist)# print(alist)# O(n^2)# 不稳定def select_sort(alist):"""选择排序"""n = len(alist)for i in range(n - 1):min_index = i # 最⼩值位置索引、下标for j in range(i+1, n):if alist[j] < alist[min_index]:min_index = j# 判断min_index ,如果和初始值不相同，作数值交换if min_index != i:alist[i], alist[min_index] = alist[min_index],alist[i]if__name__ == '__main__':alist = [8,10,15,30,25,90,66,2,999]select_sort(alist)print(alist)这是⼀些算法的时间复杂度与稳定性时间复杂度,空间复杂度 接下来就要来说说时间复杂度与空间复杂度: 时间复杂度就是假如你泡茶,从开始泡,到你喝完茶,⼀共⽤了多长时间,你中间要执⾏很多步骤,取茶叶,烧⽔,上厕所,接电话,这些都是要花时间的,在算法中,时间复杂度分为 O(1)最快 , O(nn)最慢,O(1) < O(logn) <O(n)<O(n2)<O(n3)<O(2n) <O(nn) ⼀般游览器的速度都在O(n),做我们这⼀⾏,要注意客户体验,如果你程序的运⾏特别慢,估计别⼈来⼀次,以后再也不会来了下⾯给⼤家找了张如何计算时间复杂度的图⽚: 空间复杂度(space complexity) ,执⾏时所需要占的储存空间,记做 s(n)=O(f(n)),其中n是为算法的⼤⼩, 空间复杂度绝对是效率的杀⼿,曾经看过⼀遍⽤插⼊算法的代码,来解释空间复杂度的,觉得特别厉害,我就⽐较low了,只能给⼤家简单的总结⼀下我遇到的空间复杂度了, ⼀般来说,算法的空间复杂度值得是辅助空间,⽐如:⼀组数字,时间复杂度O(n),⼆维数组a[n][m] :那么他的空间复杂度就是O(n*m) ,因为变量的内存是⾃动分配的,第⼀个的定义是循环⾥⾯的,所以是n*O(1) ,如果第⼆个循环在外边,那么就是1*O(1) ,这⾥也只是⼀个了解性的东西,如果你的⼯作中很少⽤到,那么没有必要深究,因为⽤的真的很少优化算法这边带来了代码,你们在复制下来了python上运⾏⼀下,看⼀下⽤的时间与不同, ⾃然就懂了,这是未优化的算法''已知有a,b,c三个数,都是0-1000之内的数,且: a+b+c=1000 ⽽且 a**2+b**2=c**2 ,求a,b,c⼀共有多少种组合'''# 在这⾥加⼀个时间模块,待会好计算出结果import time# 记录开头时间start_time=time.time()# 把a,b,c循环出来for a in range(1001):for b in range(1001):for c in range(100):# 判断他主公式第⼀次,并未优化if a+b+c==1000 and a**2 + b**2 == c**2 :# 打印print("a=" ,a)print("b=" ,b)print("c=" ,c)else:passstop_time = time.time()print('⼀共耗时: %f'%(stop_time-start_time))# ⼀共耗时 156.875001秒这是第⼀次优化import time# 记录开头时间start_time=time.time()# 把a,b,c循环出来for a in range(1001):# 这⾥改成1001-a之后,他就不⽤再循环b了for b in range(1001-a):for c in range(100):# 判断他主公式第⼆次,优化了b,if a+b+c==1000 and a**2 + b**2 == c**2 :print("a=" ,a)print("b=" ,b)print("c=" ,c)else:passstop_time = time.time()print('⼀共耗时: %f'%(stop_time-start_time))# ⼀共耗时 50.557070秒最后⼀次优化import time# 记录开头时间start_time=time.time()# 把a,b,c循环出来for a in range(1001):for b in range(1001-a):c=1000 - a - b# 判断他主公式第三次,优化了b和cif a+b+c==1000 and a**2 + b**2 == c**2 :print("a=" ,a)print("b=" ,b)print("c=" ,c)else:passstop_time = time.time()print('⼀共耗时: %f'%(stop_time-start_time))# ⼀共耗时 2.551449秒从156秒优化到l2秒, 基本运算总数 * 基本运算耗时 = 运算时间这之间的耗时和你的机器有着很⼤的关系今天是12⽉30⽇,明天就要跨年了,祝⼤家2019年事业有成,⼯资直线上升,早⽇脱单,。
【数据结构】常见排序算法复杂度
【数据结构】常见排序算法复杂度相关概念1、稳定排序（stable sort）和⾮稳定排序稳定排序是指所有相等的数经过某种排序算法操作后仍然能保持它们在排序之前的相对次序。
反之就是⾮稳定排序。
2、内排序（internal sorting）和外排序（external sorting）在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序；在排序过程中，只有部分数被调⼊内存，并借助内存调整数在外存中的存放顺序排序⽅法称为外排序。
排序算法【冒泡排序】（Bubble Sort）冒泡排序⽅法是最简单的排序⽅法。
这种⽅法的基本思想是，将待排序的元素看作是竖着排列的“⽓泡”，较⼩的元素⽐较轻，从⽽要往上浮。
在冒泡排序算法中我们要对这个“⽓泡”序列处理若⼲遍。
所谓⼀遍处理，就是⾃底向上检查⼀遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。
如果发现两个相邻元素的顺序不对，即“轻”的元素在下⾯，就交换它们的位置。
显然，处理⼀遍之后，“最轻”的元素就浮到了最⾼位置；处理⼆遍之后，“次轻”的元素就浮到了次⾼位置。
在作第⼆遍处理时，由于最⾼位置上的元素已是“最轻”元素，所以不必检查。
⼀般地，第i遍处理时，不必检查第i⾼位置以上的元素，因为经过前⾯i-1遍的处理，它们已正确地排好序。
冒泡排序是稳定的。
算法时间复杂度是O(n2)。
【选择排序】（Selection Sort）选择排序的基本思想是对待排序的记录序列进⾏n-1遍的处理，第 i 遍处理是将[i..n]中最⼩者与位置 i 交换位置。
这样，经过 i 遍处理之后，前 i 个记录的位置已经是正确的了。
选择排序是不稳定的。
算法复杂度是O(n2 )。
【插⼊排序】（Insertion Sort）插⼊排序的基本思想是，经过i-1遍处理后,L[1..i-1]⼰排好序。
第i遍处理仅将L插⼊L[1..i-1]的适当位置，使得L[1..i]⼜是排好序的序列。
要达到这个⽬的，我们可以⽤顺序⽐较的⽅法。
算法的时间复杂度和空间复杂度
相关知识介绍（所有定义只为帮助读者理解相关概念，并非严格定义）：1、稳定排序和非稳定排序简单地说就是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，我们就说这种排序方法是稳定的。
反之，就是非稳定的。
比如：一组数排序前是a1,a2,a3,a4,a5，其中a2=a4，经过某种排序后为a1,a2,a4,a3,a5，则我们说这种排序是稳定的，因为a2排序前在a4的前面，排序后它还是在a4的前面。
假如变成a1,a4, a2,a3,a5就不是稳定的了。
2、内排序和外排序在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序；在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法称为外排序。
3、算法的时间复杂度和空间复杂度所谓算法的时间复杂度，是指执行算法所需要的计算工作量。
一个算法的空间复杂度，一般是指执行这个算法所需要的内存空间。
功能：选择排序输入：数组名称（也就是数组首地址）、数组中元素个数算法思想简单描述：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
选择排序是不稳定的。
算法复杂度O(n2)--[n的平方void select_sort(int *x, int n){int i, j, min, t;for (i=0; i<n-1; i++) /*要选择的次数：0~n-2共n-1次*/{min = i; /*假设当前下标为i的数最小，比较后再调整*/for (j=i+1; j<n; j++)/*循环找出最小的数的下标是哪个*/{if (*(x+j) < *(x+min)){min = j; /*如果后面的数比前面的小，则记下它的下标*/}}if (min != i) /*如果min在循环中改变了，就需要交换数据*/{t = *(x+i);*(x+i) = *(x+min);*(x+min) = t;}}/*功能：直接插入排序输入：数组名称（也就是数组首地址）、数组中元素个数算法思想简单描述：在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。
算法的渐进复杂度分析
算法优化可以降低算法的渐进复杂度， 从而提高算法的效率。常见的算法优化 方法包括选择更高效的算法、减少重复 计算、使用更有效的数据结构等。
算法优化可以减少算法在处理大规模数据时 的计算量和时间复杂度，从而提高算法的实 用性。
算法优化可以改进算法的并行性和 分布式计算能力，从而更好地利用 多核处理器和分布式计算资源，提 高算法的执行效率。
在游戏开发中的算法选择与渐进复杂度分析
要点一
总结词
要点二
详细描述
游戏开发中，算法的渐进复杂度分析有助于优化游戏性能 和提升用户体验。
游戏开发中，算法的选择直接影响到游戏的运行效率和性 能表现。渐进复杂度分析可以帮助我们评估不同算法在游 戏中的性能表现，从而选择适合的算法来优化游戏性能。 例如，对于游戏物理引擎，可以使用碰撞检测和碰撞响应 算法来提高游戏交互性和真实性；对于游戏渲染，可以采 用光线追踪和阴影渲染等技术来提升画面质量和用户体验 。
渐进复杂度分析可以用于比较不同算 法的性能，为实际应用中选择合适的 算法提供依据。
促进学科发展
渐进复杂度分析是计算科学领域的重 要研究方向之一，对算法设计和分析 理论的发展具有重要意义。
未来研究方向与挑战
探索更复杂的算法模型
随着计算科学的发展，越来越多的复杂算法涌现出来，需 要发展更精确、更复杂的渐进复杂度分析方法来评估这些 算法的性能。
THANKS.
渐进复杂度通常用大O表示法来表示 ，例如O(n)、O(n^2)、O(log n)等， 其中n表示输入规模。
为什么关心算法的渐进复杂度
01
算法的效率是衡量算法好坏的重 要标准之一，而渐进复杂度是评 估算法效率的重要指标。
02
通过分析算法的渐进复杂度，可 以了解算法在不同规模输入下的 性能表现，从而在实际应用中选 择合适的算法。
迪杰斯特拉算法空间复杂度
迪杰斯特拉算法空间复杂度迪杰斯特拉算法空间复杂度概述迪杰斯特拉算法（Dijkstra's algorithm）是一种用于解决带权重图的单源最短路径问题的贪心算法。
它通过构建一个有向无环图来表示图中各节点之间的关系，并通过不断更新每个节点到起点的最短距离和路径来求解最短路径。
在实际应用中，迪杰斯特拉算法被广泛应用于计算机网络、交通运输、电信等领域。
空间复杂度迪杰斯特拉算法的空间复杂度主要包括以下几个方面：1. 图的存储方式在实现迪杰斯特拉算法时，需要将图中各节点之间的关系以及边权重等信息存储下来。
常见的图的存储方式包括邻接矩阵和邻接表两种。
邻接矩阵是一种二维数组，其中每个元素代表两个顶点之间是否存在边，如果存在则记录边权重。
邻接矩阵的空间复杂度为O(V^2)，其中V表示图中节点数。
邻接表则是一种链表数组，其中每个链表代表一个顶点，链表中存储该顶点所连的边及其权重。
邻接表的空间复杂度为O(E+V)，其中E表示图中边数。
因此，在实现迪杰斯特拉算法时，需要根据具体情况选择适合的图的存储方式，以便在满足算法要求的同时，尽可能减少空间复杂度。
2. 距离数组和标记数组在迪杰斯特拉算法中，需要使用一个距离数组和一个标记数组来记录每个节点到起点的最短距离和是否已经访问过该节点。
距离数组是一个一维数组，其中第i个元素表示从起点到节点i的最短距离。
标记数组也是一个一维数组，其中第i个元素表示节点i是否已经被访问过。
因此，在实现迪杰斯特拉算法时，需要申请两个一维数组来存储距离和标记信息。
这两个数组的空间复杂度均为O(V)，其中V表示图中节点数。
3. 优先队列在迪杰斯特拉算法中，需要使用一个优先队列来存储待访问的节点，并根据节点到起点的距离大小进行排序。
常见的优先队列包括二叉堆、斐波那契堆等。
优先队列的空间复杂度取决于具体实现方式。
例如，二叉堆的空间复杂度为O(V)，斐波那契堆的空间复杂度为O(E+VlogV)。
算法基本知识点总结
算法基本知识点总结一、算法的基本概念1. 算法的定义算法是用来解决特定问题的有限步骤的有序集合。
算法是一种计算方法，可以描述为一系列清晰的步骤，用来解决特定问题或执行特定任务。
2. 算法的特性（1）有穷性：算法必须在有限的步骤内结束。
（2）确定性：对于相同输入，算法应该产生相同的输出。
（3）可行性：算法必须可行，即算法中的每一步都可以通过已知的计算机能力来执行。
3. 算法的设计目标（1）正确性：算法应该能够解决给定的问题。
（2）可读性：算法应该易于理解和解释。
（3）高效性：算法应该能在合理的时间内完成任务。
二、算法的复杂度分析1. 时间复杂度算法的时间复杂度表示算法执行所需的时间长度，通常用“大O记法”表示。
时间复杂度反映了算法的运行时间与输入规模之间的关系。
常见的时间复杂度包括：（1）O(1)：常数时间复杂度，表示算法的运行时间与输入规模无关。
（2）O(logn)：对数时间复杂度，表示算法的运行时间与输入规模的对数成正比。
（3）O(n)：线性时间复杂度，表示算法的运行时间与输入规模成正比。
（4）O(nlogn)：线性对数时间复杂度，表示算法的运行时间与输入规模和对数成正比。
（5）O(n^2)：平方时间复杂度，表示算法的运行时间与输入规模的平方成正比。
（6）O(2^n)：指数时间复杂度，表示算法的运行时间与输入规模的指数成正比。
2. 空间复杂度算法的空间复杂度表示算法执行所需的内存空间大小。
常见的空间复杂度包括：（1）O(1)：常数空间复杂度，表示算法的内存空间与输入规模无关。
（2）O(n)：线性空间复杂度，表示算法的内存空间与输入规模成正比。
三、常见的算法设计思想1. 贪心算法贪心算法是一种选取当前最优解来解决问题的算法。
贪心算法的核心思想是从问题的某一初始解出发，通过一系列的局部最优选择，找到全局最优解。
2. 动态规划动态规划是一种将原问题分解成子问题来求解的方法。
动态规划通常适用于具有重叠子问题和最优子结构性质的问题。
VB程序设计理论课提纲-排序,分治法,哈希函数,算法时间复杂性分析
②重复①过程，直至i=n+1 且j=m+1
合并排序法算法分析
在内循环的执行次数：
每执行一次循环，完成一个元素的合并 完成合并需执行循环m+n次
算法时间复杂性O(n) 算法空间复杂度O(2n)
冒泡排序+合并排序会提高算法效率 吗？
考虑对n个数的冒泡排序
时间复杂性n2/2 空间复杂性n （需要一个数组a[1..n]）
算法的计算次数最坏情况为10001次
解方程方案二
使用二分法进行动态步长试探求算
根据题意则在区间[0,1]中有10001个可用于试探 的x值是有序排列的，可用二分法求解 算法过程见教材P.79，例4.33
算法时间复杂度最坏情况为log2n，即 15次
解方程方案三
使用牛顿切线法进行动态步长试探求算
对算法效率的认识
一．算法复杂度基本概念 二．三种控制结构的算法时间复杂度 三．降低算法复杂度的基本策略 四．排序算法复杂度的认识
一、算法复杂度基本概念
算法复杂度是指程序执行过程所占用的机 器时间和空间。 一般采用大O标记法来描述复杂度的数量级 常见的复杂度的数量级有
O(n0) ：常量级 O(n) ：线性级 O(n2) ：平方级 O(2n) ：指数级 O(log2n) ：对数级
根据题意则在区间[0,1]中的x值和y值存在函数 关系，利用函数的导数求切线与x轴的焦点作为 步长进行求解 算法过程见教材P.79，例4.32
可以证明其算法时间复杂度比二分法 还要小。
四、对排序算法复杂度的认识
数组中元素的查找策略 选择排序算法复杂 冒泡排序算法复杂 归并排序算法复杂 二路归并排序算法复杂 分治思想下的冒泡排序(快速排序）算法复 杂
算法复杂度详解
算法复杂度详解
算法复杂度是指在计算机科学中用来评估算法运行效率的一种概念，它是一个对算法运行时间或者空间需求的度量。
在实际应用中，我们常常需要对算法的复杂度进行分析，以便选择最合适的算法来解决问题。
算法复杂度通常分为时间复杂度和空间复杂度两种。
时间复杂度是指在算法执行过程中所需的时间资源，它反映了算法的执行效率。
而空间复杂度则是指算法在执行过程中所需的存储空间，它反映了算法所占用的内存资源。
通常情况下，我们更关注算法的时间复杂度，因为大多数情况下，我们更关心算法的执行时间。
在对算法的时间复杂度进行分析时，通常使用大O表示法。
大O表示法是一种用来描述函数增长趋势的渐进表示法，它用来描述函数的上界。
在算法中，我们通常使用大O表示法来估计算法的时间复杂度。
例如，如果一个算法的时间复杂度为O(n)，那么它的执行时间与输入规模n成正比；如果一个算法的时间复杂度为O(n^2)，那么它的执行时间与输入规模n的平方成正比。
在实际应用中，我们需要根据问题的特点和输入规模的大小来选择合适的算法。
对于输入规模较小的问题，我们通常可以选择时间复杂度较高但实现简单的算法；而对于输入规模较大的问题，我们则需要选择时间复杂度较低且执行效率较高的算法。
除了时间复杂度和空间复杂度之外，还有一些其他因素也会影响算法的执行效率，如硬件平台、编程语言、编译器优化等。
因此，在进行算法分析时，我们还需要考虑这些因素对算法性能的影响。
总之，算法复杂度是评估算法执行效率的重要指标，它能够帮助我们选择合适的算法来解决问题，提高程序的执行效率。
因此，掌握算法复杂度的分析方法是非常重要的。
算法时间复杂度计算公式
算法时间复杂度计算公式算法（Algorithm）是指⽤来操作数据、解决程序问题的⼀组⽅法。
对于同⼀个问题，使⽤不同的算法，也许最终得到的结果是⼀样的，但在过程中消耗的资源和时间却会有很⼤的区别。
那么我们应该如何去衡量不同算法之间的优劣呢？主要还是从算法所占⽤的「时间」和「空间」两个维度去考量。
时间维度：是指执⾏当前算法所消耗的时间，我们通常⽤「时间复杂度」来描述。
空间维度：是指执⾏当前算法需要占⽤多少内存空间，我们通常⽤「空间复杂度」来描述。
因此，评价⼀个算法的效率主要是看它的时间复杂度和空间复杂度情况。
然⽽，有的时候时间和空间却⼜是「鱼和熊掌」，不可兼得的，那么我们就需要从中去取⼀个平衡点。
下⾯我来分别介绍⼀下「时间复杂度」和「空间复杂度」的计算⽅式。
⼀、时间复杂度我们想要知道⼀个算法的「时间复杂度」，很多⼈⾸先想到的的⽅法就是把这个算法程序运⾏⼀遍，那么它所消耗的时间就⾃然⽽然知道了。
这种⽅式可以吗？当然可以，不过它也有很多弊端。
这种⽅式⾮常容易受运⾏环境的影响，在性能⾼的机器上跑出来的结果与在性能低的机器上跑的结果相差会很⼤。
⽽且对测试时使⽤的数据规模也有很⼤关系。
再者，并我们在写算法的时候，还没有办法完整的去运⾏呢。
因此，另⼀种更为通⽤的⽅法就出来了：「⼤O符号表⽰法」，即 T(n) = O(f(n))我们先来看个例⼦：for(i=1; i<=n; ++i){j = i;j++;}通过「⼤O符号表⽰法」，这段代码的时间复杂度为：O(n) ，为什么呢?在⼤O符号表⽰法中，时间复杂度的公式是： T(n) = O( f(n) )，其中f(n) 表⽰每⾏代码执⾏次数之和，⽽ O 表⽰正⽐例关系，这个公式的全称是：算法的渐进时间复杂度。
我们继续看上⾯的例⼦，假设每⾏代码的执⾏时间都是⼀样的，我们⽤ 1颗粒时间来表⽰，那么这个例⼦的第⼀⾏耗时是1个颗粒时间，第三⾏的执⾏时间是 n个颗粒时间，第四⾏的执⾏时间也是 n个颗粒时间（第⼆⾏和第五⾏是符号，暂时忽略），那么总时间就是 1颗粒时间 + n颗粒时间 + n颗粒时间，即 (1+2n)个颗粒时间，即： T(n) = (1+2n)*颗粒时间，从这个结果可以看出，这个算法的耗时是随着n的变化⽽变化，因此，我们可以简化的将这个算法的时间复杂度表⽰为：T(n) = O(n)为什么可以这么去简化呢，因为⼤O符号表⽰法并不是⽤于来真实代表算法的执⾏时间的，它是⽤来表⽰代码执⾏时间的增长变化趋势的。
几种常见算法的介绍及复杂度分析
几种常见算法的介绍及复杂度分析一、排序算法1.冒泡排序：通过反复交换相邻元素实现排序，每次遍历将最大元素放到最后。
时间复杂度为O(n^2)。
2.插入排序：将未排序元素插入已排序序列的适当位置，时间复杂度为O(n^2)。
3.选择排序：每次选择最小的元素放到已排序序列末尾，时间复杂度为O(n^2)。
4. 快速排序：通过递归将数组分段，并以一个基准元素为准将小于它的元素放在左边，大于它的元素放在右边，时间复杂度为O(nlogn)。
5. 归并排序：将数组递归拆分为多个子数组，对子数组进行排序并合并，时间复杂度为O(nlogn)。
二、查找算法1.顺序查找：从头到尾依次比较目标元素与数组中的元素，时间复杂度为O(n)。
2. 二分查找：依据已排序的数组特性，将目标元素与中间位置的元素比较，并根据大小取舍一半的数组进行查找，时间复杂度为O(logn)。
3.哈希查找：通过哈希函数将目标元素映射到数组的索引位置，时间复杂度为O(1)，但可能需要额外的空间。
三、图算法1.广度优先（BFS）：从起始节点开始，依次访问其邻居节点，再访问邻居的邻居，直到找到目标节点或遍历所有节点。
时间复杂度为O(V+E)，V为顶点数量，E为边的数量。
2.深度优先（DFS）：从起始节点开始一直遍历到没有未访问的邻居，再回溯到上一个节点继续遍历，直到找到目标节点或遍历所有节点。
时间复杂度为O(V+E)，V为顶点数量，E为边的数量。
3. 最短路径算法（如Dijkstra算法）：通过计算起始节点到每个节点的最短路径，找到起始节点到目标节点的最短路径。
时间复杂度为O(V^2)，V为顶点数量。
4. 最小生成树算法（如Prim算法）：通过贪心策略找到连通图的最小权重生成树，时间复杂度为O(V^2)，V为顶点数量。
四、动态规划算法1.背包问题：将问题拆解为若干子问题，并通过求解子问题的最优解推导出原问题的最优解。
时间复杂度为O(nW)，n为物品数量，W为背包容量。
算法的定义和特点
算法的定义和特点算法是一种计算机程序或计算机操作的任务解决思路。
在计算机领域中，算法是一种广泛应用的计算方法，其应用范围涵盖了几乎所有计算任务。
与其他解决问题的方法相比，算法具有明显的优势和特点。
本文将详细讨论算法的定义和特点，并逐一对其进行解析。
首先，算法的定义：算法是一种固定的解决问题的方法。
它是由不同的操作步骤组成，可以在有限时间内完成计算任务的计算机程序。
算法包括输入、输出、计算和操作四个基本的要素，并且规定了必须按照某种顺序执行操作，以达到预期的结果。
其次，算法的特点：复杂度、精度、稳定性。
算法的复杂度描述着算法所需计算或存储资源的大小。
可以用空间复杂度和时间复杂度来度量。
空间复杂度表示算法所需的存储资源的大小，而时间复杂度表示算法运行所需的时间。
在设计算法时，需要平衡复杂度和性能之间的矛盾；通过分析算法的复杂度，可以优化程序的性能，达到更好的效果。
算法精度是指算法中数据处理的准确性。
在算法设计中，需要考虑到使用何种数据结构、数据类型、运算符等问题，以达到更准确、更可靠的计算结果。
例如，精度高的算法在处理大数据和小数据时都能保证数据的准确性，而精度低的算法可能由于舍入误差等原因而导致计算结果的不准确。
算法稳定性是指同样的输入数据得到同样的输出数据。
即使输入数据出现变化，稳定的算法也能保证输出数据的一致性。
稳定性在算法设计中也是一个重要的考量因素。
算法的稳定性主要取决于算法的编写方式和运算结果的精度，因此在算法设计中要进行充分的考虑和测试。
除了上述特点，算法还有几个重要的特点：抽象性、通用性、可重用性。
算法的抽象性使其适用于不同的场景和计算机架构，而通用性使其可以广泛地应用到各种计算任务中。
算法的可重用性则使得算法可以用于不同的问题，节省开发时间和工作量。
综上所述，算法是一种计算机程序或计算机操作的任务解决思路。
其特点主要包括复杂度、精度、稳定性等。
在算法设计中需要平衡这些特点，以获得更好的效果。
k均值中心算法计算复杂度
k均值中心算法计算复杂度
k均值中心算法的计算复杂度主要取决于数据集的大小和迭代次数。
对于数据集大小为n，簇的个数为k，迭代次数为t的情况下，k均值中心算法的计算复杂度为O(n * k * t * d)，其中d为特征维度。
具体来说，k均值中心算法的计算复杂度包括以下几个方面：
1. 初始化簇中心：算法需要随机初始化k个簇中心，这一步的计算复杂度为O(k * d)。
2. 分配样本到簇：对于每个样本，算法需要计算其与每个簇中心的距离，并将其分配到最近的簇中。
这一步的计算复杂度为O(n * k * d)。
3. 更新簇中心：对于每个簇，算法需要计算该簇所有样本的平均值，作为新的簇中心。
这一步的计算复杂度为O(n * k * d)。
4. 迭代过程：k均值中心算法需要多次迭代来逐步优化簇中心的位置。
迭代次数t较大时，计算复杂度为O(t * n * k * d)。
k均值中心算法的计算复杂度为O(n * k * t * d)。
在实际应用中，数据集的大小、簇的个数和迭代次数都会影响算法的运行时间，需要根据具体情况进行调整。
算法复杂度——时间复杂度和空间复杂度
1.时间复杂度（1）时间频度一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。
但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。
并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。
一个算法中的语句执行次数称为语句频度或时间频度。
记为T(n)。
（2）时间复杂度在刚才提到的时间频度中，n称为问题的规模，当n不断变化时，时间频度T(n)也会不断变化。
但有时我们想知道它变化时呈现什么规律。
为此，我们引入时间复杂度概念。
一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大时，T（n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。
记作T(n)=Ｏ(f(n)),称Ｏ(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。
在各种不同算法中，若算法中语句执行次数为一个常数，则时间复杂度为O(1),另外，在时间频度不相同时，时间复杂度有可能相同，如 T(n)=n2+3n+4与T(n)=4n2+2n+1它们的频度不同，但时间复杂度相同，都为O(n2)。
按数量级递增排列，常见的时间复杂度有：常数阶O(1),对数阶O(log2n),线性阶O(n), 线性对数阶O(nlog2n),平方阶O(n2)，立方阶O(n3),...，k次方阶O(nk),指数阶O(2n)。
随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。
2、空间复杂度与时间复杂度类似，空间复杂度是指算法在计算机内执行时所需存储空间的度量。
记作: S(n)=O(f(n)) 我们一般所讨论的是除正常占用内存开销外的辅助存储单元规模。
讨论方法与时间复杂度类似，不再赘述。
（3）渐进时间复杂度评价算法时间性能主要用算法时间复杂度的数量级(即算法的渐近时间复杂度)评价一个算法的时间性能。
算法复杂度 单位
算法复杂度单位【原创版】目录一、算法复杂度的概念二、算法复杂度的单位三、算法复杂度的分析方法四、算法复杂度与程序性能的关系正文一、算法复杂度的概念算法复杂度，又称算法时间复杂度，是用来描述算法执行效率的一个指标。
它表示在规定输入规模的情况下，算法所需要执行的基本操作次数与数据量之间的增长关系。
算法复杂度是对算法性能的一种度量，它可以帮助我们了解算法的执行速度和资源消耗情况。
二、算法复杂度的单位算法复杂度的单位通常为大 O 符号（O），它表示算法的最坏情况时间复杂度。
在分析算法复杂度时，我们通常只关注最高次数，因为最高次数反映了算法的最坏情况性能。
大 O 符号表示的意义是：当输入规模趋近于无穷大时，算法的时间复杂度将趋于某个常数倍。
例如，O(n) 表示算法的时间复杂度为线性级别，O(n^2) 表示算法的时间复杂度为平方级别。
三、算法复杂度的分析方法算法复杂度的分析方法主要有两种：一种是基于数学归纳法，另一种是基于生成函数。
基于数学归纳法的分析方法通常用于解决递归算法的复杂度问题；基于生成函数的分析方法则用于解决循环算法的复杂度问题。
通过这两种方法，我们可以计算出算法的时间复杂度和空间复杂度。
四、算法复杂度与程序性能的关系算法复杂度与程序性能密切相关。
在实际应用中，算法复杂度越高，程序的执行速度就越慢，资源消耗也越大。
因此，为了提高程序的性能，我们需要尽量降低算法的复杂度。
在算法设计过程中，我们可以通过选择合适的数据结构、优化算法逻辑等方式来降低算法复杂度。
此外，在编程实践中，我们还可以利用一些优化技巧，如缓存、并行计算等，来提高程序的实际性能。
总之，算法复杂度是衡量算法性能的重要指标，它为我们提供了在算法设计、实现和优化过程中所需的重要信息。
常用算法时间复杂度的计算方法
常⽤算法时间复杂度的计算⽅法1. 时间复杂度 时间复杂度是指程序运⾏从开始到结束所需要的时间。
时间复杂度的计算⼀般⽐较⿇烦，故在数据结构的研究中很少提及时间复杂度。
为了便于⽐较同⼀个问题的不同算法，通常做法是，从算法中选取⼀种对于所研究的问题来说是基本操作的原操作，以该基本操作重复执⾏的次数做为算法的时间量度。
基本操作应是其重复执⾏次数和算法时间成正⽐的原操作，多数情况下它是最深层循环内的语句中的操作。
算法的执⾏次数还要随输⼊集有关，此时要考虑所有可能输⼊数据的期望值，此时的算法时间复杂度叫平均时间复杂度。
有事平均时间复杂度难以确定，此时分析最坏情况下算法的⼀个上界，此时称为最坏时间复杂度。
2. 时间复杂度的表⽰⽅法 设解决⼀个问题的规模为n，基本操作被重复执⾏次数是n的⼀个函数f（n），则时间复杂度可记作： T(n)=O(f(n)) 它表⽰随着问题规模n的增长，算法执⾏时的增长率和f(n)的增长率相同。
其中T(n)叫算法的渐进时间复杂度，简称时间复杂度。
算法的时间复杂度考虑的只是对于问题规模n的增长率，则在难以精确计算的情况下，只需考虑它关于n的增长率或阶即可。
例如 for(i=2;i<=n;++i) for(j=2;j<=i-1;++j) { ++x; a[i,j]=x; } 其中++x语句频度为：1+2+3+…+n-2=(n-1)(n-2)/2=(n2-3n+2)/2故算法的时间复杂度可表⽰为：T(n)=O(n2)3. 时间复杂度的计算⽅法 时间复杂的推导⽅法⼀般如下： 第⼀步：⽤常数1取代运⾏时间中的所有加法常数。
第⼆步：在修改后的运⾏次数函数中，只保留最⾼阶项。
第三步：如果最⾼阶项存在且不是1，则去除与这个项相乘的常数。
时间复杂度⼀般分为以下⼏种，分别是： （1）常数阶⾸先顺序结构的时间复杂度。
main（）{int sum=0,n=100;sum=(1+n)*n/2;printf(“%d”,sum);}算法的时间复杂度为O(1)。
克鲁斯卡尔算法空间复杂度
克鲁斯卡尔算法空间复杂度
克鲁斯卡尔算法是一种用于求解最小生成树的算法，它具有贪心
策略，即每次选择权重最小的边，将其加入生成树中。
这个算法的空
间复杂度与具体实现方式有关。
在使用克鲁斯卡尔算法时，需要将图的所有边按照权重从小到大
排序，这一步操作需要额外的空间，具体来说，需要开辟一个大小为E 的数组来存储所有边。
因此，这一步的空间复杂度为O(E)。
在选择边的过程中，需要维护一个并查集，用于判断选中的边是
否会出现环。
具体来说，需要开辟一个大小为V的数组来存储每个点
所在的连通块，因此，这一步的空间复杂度为O(V)。
在计算最终生成树的权重时，需要用到一些变量来存储当前生成
树的权重值，这些变量的空间复杂度可以忽略不计。
综上所述，克鲁斯卡尔算法的空间复杂度为O(E+V)，其中E为边
的数量，V为点的数量。
需要注意的是，由于在排序边的过程中需要用到大量的比较和交换操作，因此克鲁斯卡尔算法的时间复杂度比较高，为O(ElogE)，在边稠密的图中效率较低。
因此，在实际应用中需要根
据具体情况选择合适的算法。
算法原理知识点总结
算法原理知识点总结算法是计算机科学和信息技术领域中的重要概念，是解决问题或执行任务的一系列有序步骤的描述。
算法可以用于各种不同的情景和问题，比如搜索、排序、最短路径等。
本文将介绍一些算法的基本原理和知识点，并对一些常用的算法进行详细的介绍。
一、算法的基本原理1. 算法的定义算法是一系列步骤的描述，用于解决问题或执行任务。
这些步骤必须是有序的，并且能够在有限时间内完成。
算法可以应用于各种不同的情景和问题，比如搜索、排序、最短路径等。
2. 算法的特性算法具有以下几个特性：- 有穷性：算法必须在有限的步骤内完成；- 确定性：算法的每一步必须明确，并且具有确定的含义；- 输入：算法必须有零个或多个输入；- 输出：算法必须有一个或多个输出。
3. 算法的复杂度算法的复杂度是指算法的执行时间和空间资源的消耗。
在计算机科学和信息技术领域中，算法的复杂度通常用大O记号来表示。
大O记号描述了算法在最坏情况下的运行时间的增长速度。
4. 算法的正确性算法的正确性是指算法能够在所有输入情况下得到正确的输出。
为了验证算法的正确性，通常需要对算法进行测试，并且证明其正确性。
二、常用的算法1. 搜索算法搜索算法是用来在数据集中查找特定元素的算法。
常用的搜索算法包括线性搜索、二分搜索和哈希表等。
- 线性搜索：线性搜索是最简单的搜索算法，它遍历整个数据集，查找指定的元素。
线性搜索的时间复杂度为O(n)。
- 二分搜索：二分搜索是一种效率较高的搜索算法，它要求数据集是有序的。
二分搜索通过反复将搜索范围减半，来查找特定的元素。
二分搜索的时间复杂度为O(log n)。
- 哈希表：哈希表是一种使用哈希函数来存储和查找数据的数据结构。
哈希表的时间复杂度为O(1)。
2. 排序算法排序算法是用来将数据集中的元素按照指定的顺序进行排列的算法。
常用的排序算法包括冒泡排序、快速排序和归并排序等。
- 冒泡排序：冒泡排序是一种简单的排序算法，它通过比较相邻的元素，并交换它们的位置来进行排序。
算法复杂度的计算方法
算法复杂度的计算方法算法复杂度的计算方法什么是算法复杂度算法复杂度是衡量一个算法执行效率的指标，常用来评估算法的时间和空间消耗情况。
它能够帮助我们选择更加高效的算法，在解决问题时更有效地利用计算资源。
时间复杂度常见的时间复杂度•O(1)：常数时间复杂度，表示算法的执行时间是固定的，不随问题规模的增加而变化。
例如，查找数组中某个元素的索引。
•O(logn)：对数时间复杂度，表示算法的执行时间随问题规模的增加而呈对数增长。
例如，二分查找算法。
•O(n)：线性时间复杂度，表示算法的执行时间随问题规模的增加而呈线性增长。
例如，遍历数组求和。
•O(n^2)：平方时间复杂度，表示算法的执行时间随问题规模的增加而呈平方增长。
例如，多次嵌套循环遍历二维数组。
•O(2^n)：指数时间复杂度，表示算法的执行时间随问题规模的增加而呈指数增长。
例如，解决旅行商问题的暴力穷举法。
如何计算时间复杂度通常情况下，通过分析算法中的循环次数或者递归调用次数，可以推导出算法的时间复杂度。
以下是一些常见的情况和计算方法：•单条语句执行：如果算法中只包含一条语句，那么它的时间复杂度为O(1)，即常数时间复杂度。
•顺序执行：如果算法中包含多条语句，并且按照顺序执行，那么算法的时间复杂度取决于耗时最长的那条语句的复杂度。
•循环语句：根据循环的次数和循环体内的代码复杂度，可以推导出循环语句的时间复杂度。
•递归调用：递归算法的时间复杂度和递归调用的次数以及每次调用的复杂度有关。
空间复杂度常见的空间复杂度•O(1)：常数空间复杂度，表示算法的额外空间消耗是固定的，不随问题规模的增加而变化。
•O(n)：线性空间复杂度，表示算法的额外空间消耗随问题规模的增加而线性增长。
•O(n^2)：平方空间复杂度，表示算法的额外空间消耗随问题规模的增加而平方增长。
•O(2^n)：指数空间复杂度，表示算法的额外空间消耗随问题规模的增加而指数增长。
如何计算空间复杂度空间复杂度的计算方法与时间复杂度类似，但要注意算法中需要额外使用的空间。
算法的时间复杂度分析
算法的时间复杂度分析算法分析算法分析即指对⼀个算法所需要的资源进⾏预测内存，通信带宽或者计算机硬件等资源偶尔是我们关⼼的通常，资源是指我们希望测度的计算时间RAM模型分析⼀个算法之前，需要建⽴⼀个实现技术的模型，包括描述所⽤资源及其代价的模型RAM模型：单处理器，随机存取RAM指令⼀条接⼀条地执⾏，没有并发操作（单处理器）包含真实计算机中的常见指令：算术，数据移动，控制每条指令所需时间为常量数据类型为整型和浮点型灰⾊领域：真实计算机包含的其他指令，不是常量时间的那种。
没有对存储器层次进⾏建模。
算法运⾏时间运⾏时间取决于输⼊的内容相同规模n,不同的序列有不同的运⾏时间，⽐如逆序序列或者顺序序列运⾏时间取决于数据的规模n越⼤，时间⾃然越多⼀般来说，算法所需时间与输⼊规模同步增长，因此⼀个程序的运⾏时间是其输⼊的函数通常我们关⼼运⾏时间的上限(最坏情况)注：我们分析时间时要使⽤机器独⽴的时间单位，即不考虑机器不同带来的影响。
插⼊排序时间分析假设每⾏每次执⾏的时间为常量c ifor j: 2 to length[A]:do key = A[j]i = j-1while i>0 and A[i]>keydo A[i+1] = A[i]i = i-1A[i+1] = key1. cost:c1;times:n (包含跳出循环的那次)注：for 循环是刚刚进⼊循环时就要判断⼀次条件，然后再执⾏j--，再判断条件，直到判断条件不满⾜，不进⼊循环。
假设循环n个元素，实际执⾏n+1 次⽐较2. cost:c2;times:n−13. cost:c3;times:n−14. cost:c4;times:n∑j=2t j,t j为⼀次for循环中while循环的判断次数5. cost:c5;times:n∑j=2(t j−1),6. cost:c6;times:n∑j=2(t j−1)7. cost:c7;times:n−1t j取决于与序列排序情况有关，如果已经排好序了，A[j−1]总是⼩于key了，所以每次for循环只算判断了⼀次while，总共n−1次，如果是逆序，前⼀个总⽐后⼀个⼤，满⾜while条件，每次for循环中while判断次数为t j=j−1+1=j，总共n ∑j=2t j次。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
背景：
B1, 《从一到无穷大》这本书中，介绍了三个级别的无穷大
A，所有自然数的数目；（或整数或分数或有理数的）
B，所有实数的数目；（或无理数或复数的）
或空间中的所有几何点的数目；（或线或面或体中的）
C，空间中的所有几何曲线的数目；（或面或体中的）
虽然都是“无穷大”，但三个级别的无穷大之间是不可逾越的。
“A数了两个自然数，B已点了B级别的无穷多个点；B点了两个点，C已画了C级别的无穷多条曲线。
A数完了A级别的无穷多个自然数，B还有B级别的无穷多个点没点；B点完了B级别的无穷多个点，C还有C级别的无穷多曲线没画。
”
不同级别之间就有大小问题。
B2, 学高数时只学过高阶无穷小量,没学过高阶无穷大。
实际上，无穷小和无穷大都可以看做变量的，所以不能单纯的把他们看做一个定值。
既然高阶无穷小存在同样高阶无穷大也是存在的，只是无穷小趋近于0，可以认为其极限存在所以经常被我们用，而无穷大极限不存在，所以一般不谈其阶的问题。
如果a,b都趋向无穷小，且lima/b=0,则称a是b的高阶无穷小；
类比理解：
如果a,b都趋向无穷大，且lima/b=∞,则称a是b的高阶无穷大。
如果a,b都趋向无穷大，且lima/b=c≠0,则称a是b的同阶无穷大。
如果a,b都趋向无穷小，且lima/b=c≠0,则称a是b的同阶无穷小。
如果a,b，且lima/b=c≠0,则称a与b是同数量级的
B3, 无穷大除以无穷大，值为多少？是无穷大？还是1？还是不能确定？
无穷大也有高阶、低阶之分。
举简单的例，当x→∞时，x^6,x^3,√x都趋向无穷大，
然而x^6比x^3高阶,x^3比√x高阶。
举稍难的例，当x→+∞时，指数函数a^x比幂函数x^a(a>0)阶数高,
幂函数x^a(a>0)比对数函数log(a)x的阶数高。
当高阶无穷大除以低阶无穷大时，极限还是无穷大；
当两个同阶的无穷大相除时，极限是常数（不一定等于1）；
当低无穷大除以高阶无穷大时，极限是0（无穷小）。
大O表示法
我们需要一种方式来把空间复杂度和时间复杂度的度量弄的更精确一些，人们提出了一种标准的记法，被称为“大O表示法”。
在这种记法中使用的基本参数是n，也就是问题的规模，把复杂度表示为n的函数。
这里的“O”是英文“Order”的缩写，此处的“Order”不是“顺序”的意思，而是【数】阶, 级, 次，表示“数量级”。
比如说“数组遍历是O(n)的”，意思就是说“通过O(n)量级的步骤去遍历一个数组”。
时间复杂度
1）时间频度T(n)
一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。
但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。
并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。
一个算法中的语句执行次数称为语句频度或时间频度。
记为T(n)。
（2）时间复杂度
在刚才提到的时间频度中，n称为问题的规模，当n不断变化时，时间频度T(n)也会不断变化。
但有时我们想知道它变化时呈现什么规律。
为此，我们引入时间复杂度概念。
一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大时，T（n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。
记作T(n)=O(f(n)),称O(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。
在各种不同算法中，若算法中语句执行次数为一个常数，则时间复杂度为O(1),另外，在时间频度不相同时，时间复杂度有可能相同，如T(n)=n^2+3n+4与T(n)=4n^2+2n+1它们的频度不同，但时间复杂度相同，都为O(n^2)。
按数量级递增排列，常见的时间复杂度有：
常数阶O(1)；
对数阶O(log2n)；
线性阶O(n)；
线性对数阶O(nlog2n)；
平方阶O(n^2)；
立方阶O(n^3)；
k次方阶O(n^k)；
指数阶O(2^n)；
随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。
首先去了解数学上的无穷大的概念，然后在回来看这个东西你就会有比较深刻的理解
原来O（n^2）就是n^2同阶无穷大
例如n^2+n+3就是n^2的同阶无穷大
那么如果一个算法的复杂度是O（n）的话，我一定会选择O（n）
因为它的复杂度m ＝c×n＋d
所以也称复杂度O（n）为线性的
实际上衡量复杂度有很多种更精确的方法，但是，当规模（N）很大时，如果一个算法的时间频度为n^2+n+3，起主要作用的是n^2 所以就近似的用同阶无穷大O（n^2）来衡量一个算法的复杂度了
衡量算法好坏的标准.比如说: O(n^2)肯定比O(n)要差,因为O(n)的计算时间只是与n成正比(O(n)是的n同数量级函数),而O(n^2)的计算时间与n^2成正比(O(n)是n^2的同数量级函数). 一般来说,算法的好坏只有当计算量大时才能有区别,计算量的大小一般就用n来代表.举例来说,对一个数组进行排序,数组中的元素个数就是衡量的标准.两种算法都对一个3个元素的数组排序,好坏是没有什么区别的.在N较大时,比如说,一个算法用1天,而另一个算法只用1小时,是不是区别就大了.在N较大时,一些小的代价就可以忽略了.O(f(n))是指算法的时间是在什么量级的.
时间代价和空间代价在很多时候是此消彼长的。
如内存和CPU时间，用大量的内存可以换取低一些的CPU时间。
反之用很高的CPU时间可以换取较低的内存占用。
算法的时间复杂度和空间复杂度是矛盾的两个方面喽。
确实是鱼与熊掌不可兼得！
f(n)代表一个算法本身以n为变元的算杂度函数，常见的就是指数，对数和线性关系。
O（f(n)）则表示在此算法复杂度之下与系统代价的关系。
f(n)是一个—维的关系，O（f(n)）则代表一个二维的关系。
那句话说明了，在一个复杂度平面中，存在着一条曲线C*f(n)，使得T（n）=0（f(n)）在任一给定n值,总有<=c*f(n)。
=值就是两条曲线的切点。
如：y=f(n),则T(n)=O(y),由于两次非线性的关系使得算法好坏的度量变得复杂，因此用T（n）<= C*f(n)来简化算法的估量。
不得已而为之呀。