空间复杂度与时间复杂度
算法分类,时间复杂度,空间复杂度,优化算法
算法分类,时间复杂度,空间复杂度,优化算法算法 今天给⼤家带来⼀篇关于算法排序的分类,算法的时间复杂度,空间复杂度,还有怎么去优化算法的⽂章,喜欢的话,可以关注,有什么问题,可以评论区提问,可以与我私信,有什么好的意见,欢迎提出.前⾔: 算法的复杂度分为时间复杂度与空间复杂度,时间复杂度指执⾏算法需要需要的计算⼯作量,空间复杂度值执⾏算法需要的内存量,可能在运⾏⼀些⼩数据的时候,⼤家体会不到算法的时间与空间带来的体验. 优化算法就是将算法的时间优化到最快,将空间优化到最⼩,假如你写的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.空间复杂度
空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度，记做S(n)=O(f(n))。
比如直接插入排序的时间复杂度是O(n^2),空间复杂度是O(1) 。
而一般的递归算法就要有O(n)的空间复杂度了，因为每次递归都要存储返回信息。
一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量。
2. 时间复杂度
在计算机科学中，时间复杂性，又称时间复杂度，算法的时间复杂度是一个函数，它定性描述该算法的运行时间。
这是一个代表算法输入值的字符串的长度的函数。
时间复杂度常用大O符号表述，不包括这个函数的低阶项和首项系数。
使用这种方式时，时间复杂度可被称为是渐近的，亦即考察输入值大小趋近无穷时的情况。
链表的时间复杂度和空间复杂度
链表的时间复杂度和空间复杂度
链表是一种常用的数据结构，它是由一组节点组成的有序集合，每个节点包含两个部分：数据域和指针域。
链表的优点在于可以随机访问链表中的任何一个节点，缺点在于插入、删除操作比较麻烦。
链表的时间复杂度指的是链表执行某个操作的时间复杂度。
链表的时间复杂度主要有以下几种：
增加、删除节点：在链表头和链表尾添加、删除节点的时间复杂度为O(1)，在链表中间添加、删除节点的时间复杂度为O(n)。
查找节点：在链表中查找某个节点的时间复杂度为O(n)。
链表的空间复杂度指的是链表所占用的存储空间。
链表的空间复杂度主要有以下几种：
静态链表：静态链表是指在编译时就分配好了存储空间的链表，它的空间复杂度为O(n)。
动态链表：动态链表是指在运行时动态分配存储空间的链表，它的空间复杂度为O(n)。
总的来说，链表的时间复杂度主要取决于链表的操作，增加、删除节点和查找节点的时间复杂度分别为O(1) 和O(n)。
链表的空间复杂度取决于是静态链表还是动态链表，静态链表的空间复杂度为O(n)，动态链表的空间复杂度也为O(n)。
需要注意的是，链表的时间复杂度和空间复杂度并不是固定的，实际情况会受到许多因素的影响，比如链表的结构、数据量等。
在使用链表时，应根据实际情况合理选择并使用适当的数据结构。
程序优化的十个维度
程序优化的十个维度
1. 时间复杂度：优化算法和数据结构，减少时间复杂度。
2. 空间复杂度：减少内存的使用，优化程序的空间开销。
3. 并发性：使用多线程或者并发机制，提高程序的并发性。
4. 编译优化：使用编译器提供的优化选项，提高程序的执行效率。
5. 缓存优化：充分利用缓存，减少读写操作对缓存的影响。
6. IO优化：减少IO操作，缓存IO操作，并对数据进行
压缩等处理，提高IO效率。
7. 数据结构优化：选择适合的数据结构，优化数据结构的存储方式及访问方式。
8. 内存管理优化：充分利用内存，减少内存碎片与内存泄漏，优化内存管理算法。
9. 磁盘访问优化：减少磁盘寻址和旋转时间，减少磁头移位的时间，提高磁盘访问效率。
10. 代码优化：针对程序中存在的瓶颈部分进行代码优化，提高程序的执行效率。
算法的时间复杂度和空间复杂度的关系
算法的时间复杂度和空间复杂度的关系
时间复杂度和空间复杂度是算法分析中最重要的概念，它们可以帮助我们评估算法的性能。
时间复杂度描述了算法执行所需的时间，而空间复杂度描述了算法执行所需的内存空间。
时间复杂度是指算法执行所需的时间，它可以用大O表示法来表示，其中O(n)表示算法
的时间复杂度为n，即算法的执行时间与输入数据的大小成正比。
一般来说，算法的时间
复杂度越低，它的执行效率就越高。
空间复杂度是指算法执行所需的内存空间，它也可以用大O表示法来表示，其中O(n)表
示算法的空间复杂度为n，即算法所需的内存空间与输入数据的大小成正比。
一般来说，
算法的空间复杂度越低，它的内存使用效率就越高。
时间复杂度和空间复杂度之间存在一定的关系，即算法的时间复杂度越低，它的空间复杂度也越低。
这是因为算法的时间复杂度越低，它所需的计算量就越少，因此它所需的内存
空间也就越少。
反之，算法的时间复杂度越高，它所需的计算量就越多，因此它所需的内
存空间也就越多。
因此，我们可以从算法的时间复杂度来推断它的空间复杂度，从而更好地评估算法的性能。
但是，有时候算法的时间复杂度和空间复杂度可能不是成正比的，因此我们还需要对算法
的空间复杂度进行具体的分析，以便更好地评估算法的性能。
总之，时间复杂度和空间复杂度是算法分析中最重要的概念，它们可以帮助我们评估算法的性能。
算法的时间复杂度越低，它的空间复杂度也越低，但有时候它们之间的关系可能
不是成正比的，因此我们还需要对算法的空间复杂度进行具体的分析，以便更好地评估算
法的性能。
常用排序算法的时间复杂度和空间复杂度
常⽤排序算法的时间复杂度和空间复杂度以上快速排序和归并排序的空间复杂度不正确没有的参考图1，以图2为准（对，就是懒得重新画图了）排序法最差时间分析平均时间复杂度稳定度空间复杂度冒泡排序O(n2)O(n2)稳定O(1)快速排序O(n2)O(n*log2n)不稳定O(log2n)~O(n)选择排序O(n2)O(n2)稳定O(1)⼆叉树排O(n2)O(n*log2n)不稳定O(n)序插⼊排序O(n2)O(n2)稳定O(1)堆排序O(n*log2n)O(n*log2n)不稳定O(1)希尔排序O O不稳定O(1)1.插⼊排序由N-1趟排序组成，对于p=1到p=N-1趟，插⼊排序保证从位置0到位置p上的元素为已排序状态。
时间复杂度：O(N^2)代码void InsertionSort(ElementType A[],int N){int j,p;ElementType Tmp;for(p=1;p<N;p++){Tmp=A[j];//把A[j]保存下来，因为它要被插⼊到前⾯的某个位置去for(j=p;j>0&&A[j-1]>Tmp;j--)//⼤于A[j]的元素逐个后移{A[j]=A[j-1];}A[j]=Tmp;}}2.希尔排序希尔排序使⽤⼀个序列h1，h2，h3，ht，叫做增量排序。
在使⽤增量hk的⼀趟排序之后，对于每个i我们有A[i]<A[i+hk]，所有相隔hk的元素被排序。
时间复杂度：O(N^(1+a))，其中0<a<1。
//代码不太好理解，使⽤了3层循环void ShellSort(ElementType A[],int N){int j,p,Increment;ElementType Tmp;for(Increment=N/2;Increment>0;Increment/=2){for(p=Increment;p<N;p++){Tmp=A[p];for(j=p;j>=Increment;j-=Increment){if(A[j]<A[j-Increment])A[j]=A[j-Increment];elsebreak;}A[j]=Tmp;}}}3. 堆排序思想：建⽴⼩顶堆，然后执⾏N次deleteMin操作。
如何计算时间复杂度和空间复杂度
如何计算时间复杂度和空间复杂度计算时间复杂度和空间复杂度是衡量算法效率的重要方法，可以通过对算法的代码进行分析和推算来得出。
时间复杂度描述了算法运行时间随输入规模增长而增长的趋势，通常用大O符号表示。
在计算时间复杂度时，我们需要关注算法中的循环、递归、条件分支等关键代码块。
以下是计算时间复杂度的一些常见方法：1.计算常数时间复杂度：如果一个算法的代码只包含固定数量的操作，不随输入规模变化，那么它的时间复杂度为O(1)。
例如，简单的赋值、比较和常量运算等操作。
2.计算线性时间复杂度：如果一个算法的代码中包含一个循环，该循环的迭代次数与输入规模n成正比，那么其时间复杂度为O(n)。
例如，遍历一个数组或者链表的操作。
3.计算平方时间复杂度：如果一个算法的代码中包含两个嵌套的循环，外层循环的迭代次数与输入规模n成正比，内层循环的迭代次数也与输入规模n成正比，那么其时间复杂度为O(n^2)。
例如，二重循环嵌套的矩阵操作。
4.计算指数时间复杂度：如果一个算法的代码中包含递归调用，且递归次数与输入规模n成正比，那么其时间复杂度可能是指数级别的，如O(2^n)。
例如，求解斐波那契数列的递归算法。
计算空间复杂度是用来衡量算法所需的额外存储空间随输入规模增长而增长的趋势。
以下是计算空间复杂度的一些常见方法：1.计算固定空间复杂度：如果一个算法的代码所需的额外存储空间不随输入规模变化，那么它的空间复杂度为O(1)。
例如，仅需要几个变量来存储中间计算结果的操作。
2.计算线性空间复杂度：如果一个算法的代码所需的额外存储空间随输入规模n成正比，那么它的空间复杂度为O(n)。
例如，需要创建一个数组或链表来存储输入数据的操作。
3.计算递归空间复杂度：如果一个算法中使用了递归调用，那么每个递归调用都需要创建一个新的函数调用栈帧，因此空间复杂度可能是O(n)，其中n是递归的深度。
例如，递归求解二叉树问题的操作。
在进行时间复杂度和空间复杂度的计算时，可以按照以下步骤进行：1.根据算法的代码，找出其中的关键代码块，例如循环、递归等。
各种排序算法的时间复杂度和空间复杂度（阿里）
各种排序算法的时间复杂度和空间复杂度（阿⾥）⼆分查找法的时间复杂度：O(logn) redis,kafka,B+树的底层都采⽤了⼆分查找法参考：⼆分查找法 redis的索引底层的跳表原理实现参考：⼆分查找法参考：⼆分查找法：1.⼆分查找⼆分查找也称为折半查找，它是⼀种效率较⾼的查找⽅法。
⼆分查找的使⽤前提是线性表已经按照⼤⼩排好了序。
这种⽅法充分利⽤了元素间的次序关系，采⽤分治策略。
基本原理是：⾸先在有序的线性表中找到中值，将要查找的⽬标与中值进⾏⽐较，如果⽬标⼩于中值，则在前半部分找，如果⽬标⼩于中值，则在后半部分找；假设在前半部分找，则再与前半部分的中值相⽐较，如果⼩于中值，则在中值的前半部分找，如果⼤于中值，则在后半部分找。
以此类推，直到找到⽬标为⽌。
假设我们要在 2，6，11，13，16，17，22，30中查找22，上图所⽰，则查找步骤为：⾸先找到中值：中值为13（下标：int middle = (0+7)/2），将22与13进⾏⽐较，发现22⽐13⼤，则在13的后半部分找；在后半部分 16，17，22，30中查找22，⾸先找到中值，中值为17（下标：int middle=(0+3)/2），将22与17进⾏⽐较，发现22⽐17⼤，则继续在17的后半部分查找；在17的后半部分 22，30查找22，⾸先找到中值，中值为22（下标：int middle=(0+1)/2），将22与22进⾏⽐较，查找到结果。
⼆分查找⼤⼤降低了⽐较次数，⼆分查找的时间复杂度为：O(logn)，即。
⽰例代码：public class BinarySearch {public static void main(String[] args) {int arr[] = {2, 6, 11, 13, 16, 17, 22, 30};System.out.println("⾮递归结果,22的位置为:" + binarySearch(arr, 22));System.out.println("递归结果,22的位置为:" + binarySearch(arr, 22, 0, 7));}//⾮递归static int binarySearch(int[] arr, int res) {int low = 0;int high = arr.length-1;while(low <= high) {int middle = (low + high)/2;if(res == arr[middle]) {return middle;}else if(res <arr[middle]) {high = middle - 1;}else {low = middle + 1;}}return -1;}//递归static int binarySearch(int[] arr,int res,int low,int high){if(res < arr[low] || res > arr[high] || low > high){return -1;}int middle = (low+high)/2;if(res < arr[middle]){return binarySearch(arr, res, low, middle-1);}else if(res > arr[middle]){return binarySearch(arr, res, middle+1, high);}else {return middle;}}}其中冒泡排序加个标志，所以最好情况下是o(n)直接选择排序：排序过程：1 、⾸先在所有数据中经过 n-1次⽐较选出最⼩的数，把它与第 1个数据交换，2、然后在其余的数据内选出排序码最⼩的数，与第 2个数据交换...... 依次类推，直到所有数据排完为⽌。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
空间复杂度与时间复杂度用于衡量一个算法的效率。
- 时间复杂度
首先举几个小例子：
一个简单的for循环
for(int i = 0;i<6;i++){
//生成一个97-122之间的int类型整数65-90大写
int intVal = (int)(Math.random() * 26 + 97);
//将intVal强制转换为char类型后连接到result后面
result = result + (char)intVal;
}
上述代码中，总共执行了6次，对于这种常数的复杂度，经常会用O(1)来表示。
接下来，看这个代码：
for(int i=0;i<2; i++){
for(int j = 0; j <n; j++){
System.out.print(s[i][j]);
}
System.out.println();
}
这段代码是两个for循环嵌套，它的时间复杂度很容易看出是2n，通常这种我们用O(n)进行表示，表明它是线性变化的。
从上面举的两个例子可以看出，时间复杂度就是整个语句在执行过程中，根据所给的条件，在整个代码运行过程中所执行的次数，这个执行次数与所给的添加和执行参数的大小息息相关。
- 空间复杂度
空间复杂度通常指的是算法程序在计算机计算中计算所需要的存储空间。
空间复杂度可从以下两个方面去描述：
•程序保存所需要的存储空间，即程序的大小
•程序在执行过程中所需要消耗的存储空间资源，例如，程序在执行过程中的中间变量。