几种排序的算法时间复杂度比较
排序算法比较
排序算法比较
排序算法的效率主要取决于算法的时间复杂度。
以下是常见的几种排序算法的时间复杂度和优缺点的对比：
1. 冒泡排序
冒泡排序的时间复杂度为O(n^2)。
优点是它的实现简单易懂，缺点是排序速度很慢，对大规模数据排序不太适用。
2. 插入排序
插入排序的时间复杂度也为 O(n^2)。
它的优点是适用于小数
据量的排序，缺点是对于大规模数据排序仍然效率不高。
3. 选择排序
选择排序的时间复杂度也为 O(n^2)。
它的优点是对于小数据
量的排序速度较快，但是因为其算法结构固定，所以其效率在大规模数据排序中表现不佳。
4. 快速排序
快速排序的时间复杂度为 O(nlogn)。
它是一种非常常用的排序算法，适用于大规模数据排序。
快速排序的优点在于分治的思想，可以充分发挥多线程并行计算的优势，缺点是在极端情况下（如输入的数据已经有序或者逆序）排序速度会较慢。
5. 堆排序
堆排序的时间复杂度为 O(nlogn)。
它的优点在于实现简单、稳定，可以用于实时系统中的排序。
缺点是在排序过程中需要使用一个堆结构来维护排序序列，需要额外的内存开销。
同时，由于堆的性质，堆排序不能发挥多线程并行计算的优势。
6. 归并排序
归并排序的时间复杂度为 O(nlogn)。
它的优点在于稳定、可靠，效率在大规模数据排序中表现良好。
归并排序在实现过程中需要使用递归调用，需要额外的内存开销。
同时，归并排序不适用于链式存储结构。
各种排序的时间复杂度
排序算法所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
分类在计算机科学所使用的排序算法通常被分类为：计算的复杂度（最差、平均、和最好表现），依据串列（list）的大小（n）。
一般而言，好的表现是O。
(n log n)，且坏的行为是Ω(n2)。
对於一个排序理想的表现是O(n)。
仅使用一个抽象关键比较运算的排序算法总平均上总是至少需要Ω(n log n)。
记忆体使用量（以及其他电脑资源的使用）稳定度：稳定排序算法会依照相等的关键（换言之就是值）维持纪录的相对次序。
也就是一个排序算法是稳定的，就是当有两个有相等关键的纪录R和S，且在原本的串列中R出现在S之前，在排序过的串列中R也将会是在S之前。
一般的方法：插入、交换、选择、合并等等。
交换排序包含冒泡排序（bubble sort）和快速排序（quicksort）。
选择排序包含shaker排序和堆排序（heapsort）。
当相等的元素是无法分辨的，比如像是整数，稳定度并不是一个问题。
然而，假设以下的数对将要以他们的第一个数字来排序。
(4, 1) (3, 1) (3, 7) (5, 6)在这个状况下，有可能产生两种不同的结果，一个是依照相等的键值维持相对的次序，而另外一个则没有：(3, 1) (3, 7) (4, 1) (5, 6) (维持次序)(3, 7) (3, 1) (4, 1) (5, 6) (次序被改变)不稳定排序算法可能会在相等的键值中改变纪录的相对次序，但是稳定排序算法从来不会如此。
不稳定排序算法可以被特别地时作为稳定。
作这件事情的一个方式是人工扩充键值的比较，如此在其他方面相同键值的两个物件间之比较，就会被决定使用在原先资料次序中的条目，当作一个同分决赛。
然而，要记住这种次序通常牵涉到额外的空间负担。
排列算法列表在这个表格中，n是要被排序的纪录数量以及k是不同键值的数量。
稳定的冒泡排序（bubble sort）— O(n2)鸡尾酒排序 (Cocktail sort, 双向的冒泡排序) — O(n2)插入排序（insertion sort）— O(n2)桶排序（bucket sort）— O(n); 需要 O(k) 额外记忆体计数排序 (counting sort) — O(n+k); 需要 O(n+k) 额外记忆体归并排序（merge sort）— O(n log n); 需要 O(n) 额外记忆体原地归并排序— O(n2)二叉树排序（Binary tree sort）— O(n log n); 需要 O(n) 额外记忆体鸽巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 额外记忆体基数排序（radix sort）—O(n·k); 需要 O(n) 额外记忆体Gnome sort — O(n2)Library sort — O(n log n) with high probability, 需要(1+ε)n 额外记忆体不稳定选择排序（selection sort）— O(n2)希尔排序（shell sort）— O(n log n) 如果使用最佳的现在版本Comb sort — O(n log n)堆排序（heapsort）— O(n log n)Smoothsort — O(n log n)快速排序（quicksort）—O(n log n) 期望时间, O(n2) 最坏情况; 对於大的、乱数串列一般相信是最快的已知排序Introsort — O(n log n)Patience sorting —O(n log n + k) 最外情况时间, 需要额外的 O(n + k) 空间, 也需要找到最长的递增子序列（longest increasing subsequence）不实用的排序算法Bogo排序—O(n × n!) 期望时间, 无穷的最坏情况。
十大经典排序算法总结
⼗⼤经典排序算法总结最近⼏天在研究算法，将⼏种排序算法整理了⼀下，便于对这些排序算法进⾏⽐较，若有错误的地⽅，还请⼤家指正0、排序算法说明0.1 排序术语稳定：如果a=b,且a原本排在b前⾯，排序之后a仍排在b的前⾯不稳定：如果a=b,且a原本排在b前⾯，排序之后排在b的后⾯时间复杂度：⼀个算法执⾏所耗费的时间空间复杂度：⼀个算法执⾏完所需内存的⼤⼩内排序：所有排序操作都在内存中完成外排序：由于数据太⼤，因此把数据放在磁盘中，⽽排序通过磁盘和内存的数据传输才能进⾏0.2算法时间复杂度、空间复杂度⽐较0.3名词解释n:数据规模k:桶的个数In-place:占⽤常数内存，不占⽤额外内存Out-place:占⽤额外内存0.4算法分类1.冒泡排序冒泡排序是⼀种简单的排序算法。
它重复地⾛访过要排序的数列，⼀次⽐较两个元素，如果它们的顺序错误就把它们交换过来。
⾛访数列的⼯作是重复地进⾏直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越⼩的元素会经由交换慢慢“浮”到数列的顶端1.1算法描述⽐较相邻的元素，如果前⼀个⽐后⼀个打，就交换对每⼀对相邻元素做同样的⼯作，从开始第⼀对到结尾最后⼀对，这样在最后的元素应该会是最⼤的数针对所有的元素重复以上的步骤，除了最后⼀个重复步骤1-3，知道排序完成1.2动图演⽰1.3代码实现public static int[] bubbleSort(int[] array) {if (array.length == 0)return array;for (int i = 0; i < array.length; i++)for (int j = 0; j < array.length - 1 - i; j++)if (array[j + 1] < array[j]) {int temp = array[j + 1];array[j + 1] = array[j];array[j] = temp;}return array;}1.4算法分析最佳情况：T(n) = O(n) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)2.选择排序表现简单直观的最稳定的排序算法之⼀，因为⽆论什么数据都是O(n2)的时间复杂度，⾸先在未排序序列中找到最⼩（⼤）元素，与数组中第⼀个元素交换位置，作为排序序列的起始位置，然后再从剩余未排序元素中继续寻找最⼩（⼤）的元素，与数组中的下⼀个元素交换位置，也就是放在已排序序列的末尾2.1算法描述1.初始状态：⽆序区为R[1..n],有序区为空2.第i躺排序开始时，当前有序区和⽆序区R[1..i-1]、R[i..n]3.n-1趟结束，数组有序化2.2动图演⽰2.3代码实现public static int[] selectionSort(int[] array) {if (array.length == 0)return array;for (int i = 0; i < array.length; i++) {int minIndex = i;for (int j = i; j < array.length; j++) {if (array[j] < array[minIndex]) //找到最⼩的数minIndex = j; //将最⼩数的索引保存}int temp = array[minIndex];array[minIndex] = array[i];array[i] = temp;}return array;}2.4算法分析最佳情况：T(n) = O(n2) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)3、插⼊排序是⼀种简单直观的排序算法，通过构建有序序列，对于未排序序列，在已排序序列中从后向前扫描，找到相应位置并插⼊，需要反复把已排序元素逐步向后挪位，为最新元素腾出插⼊空间3.1算法描述1.从第⼀个元素开始，该元素可以认为已经被排序2.取出下⼀个元素（h），在已排序的元素序列中从后往前扫描3.如果当前元素⼤于h，将当前元素移到下⼀位置4.重复步骤3，直到找到已排序的元素⼩于等于h的位置5.将h插⼊到该位置6.重复步骤2-53.2动图演⽰3.3代码实现public static int[] insertionSort(int[] array) {if (array.length == 0)return array;int current;for (int i = 0; i < array.length - 1; i++) {current = array[i + 1];int preIndex = i;while (preIndex >= 0 && current < array[preIndex]) {array[preIndex + 1] = array[preIndex];preIndex--;}array[preIndex + 1] = current;}return array;}3.4算法分析最佳情况：T(n) = O(n) 最坏情况：T(n) = O(n2) 平均情况：T(n) = O(n2)4、希尔排序是简单插⼊排序经过改进之后的⼀个更⾼效的版本，也称为缩⼩增量排序，同时该算法是冲破O(n2）的第⼀批算法之⼀。
算法分类,时间复杂度,空间复杂度,优化算法
算法分类,时间复杂度,空间复杂度,优化算法算法 今天给⼤家带来⼀篇关于算法排序的分类,算法的时间复杂度,空间复杂度,还有怎么去优化算法的⽂章,喜欢的话,可以关注,有什么问题,可以评论区提问,可以与我私信,有什么好的意见,欢迎提出.前⾔: 算法的复杂度分为时间复杂度与空间复杂度,时间复杂度指执⾏算法需要需要的计算⼯作量,空间复杂度值执⾏算法需要的内存量,可能在运⾏⼀些⼩数据的时候,⼤家体会不到算法的时间与空间带来的体验. 优化算法就是将算法的时间优化到最快,将空间优化到最⼩,假如你写的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年事业有成,⼯资直线上升,早⽇脱单,。
排序—时间复杂度为O（n2）的三种排序算法
排序—时间复杂度为O（n2）的三种排序算法1 如何评价、分析⼀个排序算法？很多语⾔、数据库都已经封装了关于排序算法的实现代码。
所以我们学习排序算法⽬的更多的不是为了去实现这些代码，⽽是灵活的应⽤这些算法和解决更为复杂的问题，所以更重要的是学会如何评价、分析⼀个排序算法并在合适的场景下正确使⽤。
分析⼀个排序算法，主要从以下3个⽅⾯⼊⼿：1.1 排序算法的执⾏效率1）最好情况、最坏情况和平均情况时间复杂度待排序数据的有序度对排序算法的执⾏效率有很⼤影响，所以分析时要区分这三种时间复杂度。
除了时间复杂度分析，还要知道最好、最坏情况复杂度对应的要排序的原始数据是什么样的。
2）时间复杂度的系数、常数和低阶时间复杂度反映的是算法执⾏时间随数据规模变⼤的⼀个增长趋势，平时分析时往往忽略系数、常数和低阶。
但如果我们排序的数据规模很⼩，在对同⼀阶时间复杂度的排序算法⽐较时，就要把它们考虑进来。
3）⽐较次数和交换（移动）次数内排序算法中，主要进⾏⽐较和交换（移动）两项操作，所以⾼效的内排序算法应该具有尽可能少的⽐较次数和交换次数。
1.2 排序算法的内存消耗也就是分析算法的空间复杂度。
这⾥还有⼀个概念—原地排序，指的是空间复杂度为O(1)的排序算法。
1.3 稳定性如果待排序的序列中存在值相等的元素，经过排序之后，相等元素之间原有的先后顺序不变，那么这种排序算法叫做稳定的排序算法；如果前后顺序发⽣变化，那么对应的排序算法就是不稳定的排序算法。
在实际的排序应⽤中，往往不是对单⼀关键值进⾏排序，⽽是要求排序结果对所有的关键值都有序。
所以，稳定的排序算法往往适⽤场景更⼴。
2 三种时间复杂度为O(n2)的排序算法2.1 冒泡排序2.1.1 原理两两⽐较相邻元素是否有序，如果逆序则交换两个元素，直到没有逆序的数据元素为⽌。
每次冒泡都会⾄少让⼀个元素移动到它应该在的位置。
2.1.2 实现void BubbleSort(int *pData, int n) //冒泡排序{int temp = 0;bool orderlyFlag = false; //序列是否有序标志for (int i = 0; i < n && !orderlyFlag; ++i) //执⾏n次冒泡{orderlyFlag = true;for (int j = 0; j < n - 1 - i; ++j) //注意循环终⽌条件{if (pData[j] > pData[j + 1]) //逆序{orderlyFlag = false;temp = pData[j];pData[j] = pData[j + 1];pData[j + 1] = temp;}}}}测试结果2.1.3 算法分析1）时间复杂度最好情况时间复杂度：当待排序列已有序时，只需⼀次冒泡即可。
常用排序算法的时间复杂度和空间复杂度
常⽤排序算法的时间复杂度和空间复杂度以上快速排序和归并排序的空间复杂度不正确没有的参考图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操作。
几种排序的算法时间复杂度比较
几种排序的算法时间复杂度比较1.选择排序：不稳定，时间复杂度 O(n^2)选择排序的基本思想是对待排序的记录序列进行n-1遍的处理，第i遍处理是将L[i..n]中最小者与L[i]交换位置。
这样，经过i遍处理之后，前i个记录的位置已经是正确的了。
2.插入排序：稳定，时间复杂度 O(n^2)插入排序的基本思想是，经过i-1遍处理后,L[1..i-1]己排好序。
第i遍处理仅将L[i]插入L[1..i-1]的适当位置，使得L[1..i] 又是排好序的序列。
要达到这个目的，我们可以用顺序比较的方法。
首先比较L[i]和L[i-1]，如果L[i-1]≤ L[i]，则L[1..i]已排好序，第i遍处理就结束了；否则交换L[i]与L[i-1]的位置，继续比较L[i-1]和L[i-2]，直到找到某一个位置j(1≤j≤i-1)，使得L[j] ≤L[j+1]时为止。
图1演示了对4个元素进行插入排序的过程，共需要(a),(b),(c)三次插入。
3.冒泡排序：稳定，时间复杂度 O(n^2)冒泡排序方法是最简单的排序方法。
这种方法的基本思想是，将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮。
在冒泡排序算法中我们要对这个“气泡”序列处理若干遍。
所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。
如果发现两个相邻元素的顺序不对，即“轻”的元素在下面，就交换它们的位置。
显然，处理一遍之后，“最轻”的元素就浮到了最高位置；处理二遍之后，“次轻”的元素就浮到了次高位置。
在作第二遍处理时，由于最高位置上的元素已是“最轻”元素，所以不必检查。
一般地，第i遍处理时，不必检查第i高位置以上的元素，因为经过前面i-1遍的处理，它们已正确地排好序。
4.堆排序：不稳定，时间复杂度 O(nlog n)堆排序是一种树形选择排序，在排序过程中，将A[n]看成是完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系来选择最小的元素。
各种排序算法的时间复杂度和空间复杂度（阿里）
各种排序算法的时间复杂度和空间复杂度（阿⾥）⼆分查找法的时间复杂度：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)。
几种排序的算法时间复杂度比较
1.选择排序：不稳定，时间复杂度 O(n^2)
选择排序的基本思想是对待排序的记录序列进行n-1遍的处理，第i遍处理是将L[i..n]中最小者与L[i]交换位置。
这样，经过i遍处理之后，前i个记录的位置已经是正确的了。
2.插入排序：稳定，时间复杂度 O(n^2)
插入排序的基本思想是，经过i-1遍处理后,L[1..i-1]己排好序。
第i遍处理仅将L[i]插入L[1..i-1]的适当位置，使得L[1..i] 又是排好序的序列。
要达到这个目的，我们可以用顺序比较的方法。
首先比较L[i]和L[i-1]，如果L[i-1]≤ L[i]，则L[1..i]已排好序，第i遍处理就结束了；否则交换L[i]与L[i-1]的位置，继续比较L[i-1]和L[i-2]，直到找到某一个位置j(1≤j≤i-1)，使得L[j] ≤L[j+1]时为止。
图1演示了对4个元素进行插入排序的过程，共需要(a),(b),(c)三次插入。
3.冒泡排序：稳定，时间复杂度 O(n^2)
冒泡排序方法是最简单的排序方法。
这种方法的基本思想是，将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮。
在冒泡排序算法中我们要对这个“气泡”序列处理若干遍。
所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。
如果发现两个相邻元素的顺序不对，即“轻”的元素在下面，就交换它们的位置。
显然，处理一遍之后，“最轻”的元素就浮到了最高位置；处理二遍之后，“次轻”的元素就浮到了次高位置。
在作第二遍处理时，由于最高位置上的元素已是“最轻”元素，所以不必检查。
一般地，第i遍处理时，不必检查第i高位置以上的元素，因为经过前面i-1遍的处理，它们已正确地排好序。
4.堆排序：不稳定，时间复杂度 O(nlog n)
堆排序是一种树形选择排序，在排序过程中，将A[n]看成是完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系来选择最小的元素。
5.归并排序：稳定，时间复杂度 O(nlog n)
设有两个有序（升序）序列存储在同一数组中相邻的位置上，不妨设为
A[l..m]，A[m+1..h]，将它们归并为一个有序数列，并存储在A[l..h]。
6.快速排序：不稳定，时间复杂度最理想 O(nlogn) 最差时间O(n^2)
快速排序是对冒泡排序的一种本质改进。
它的基本思想是通过一趟扫描后，使得排序序列的长度能大幅度地减少。
在冒泡排序中，一次扫描只能确保最大数值的数移到正确位置，而待排序序列的长度可能只减少1。
快速排序通过一趟扫描，就能确保某个数（以它为基准点吧）的左边各数都比它小，右边各数都比它大。
然后又用同样的方法处理它左右两边的数，直到基准点的左右只有一个元素为止。
7.希尔排序：不稳定，时间复杂度平均时间 O(nlogn) 最差时间O(n^s) 1<s<2
在直接插入排序算法中，每次插入一个数，使有序序列只增加1个节点，并且对插入下一个数没有提供任何帮助。
如果比较相隔较远距离（称为增量）的数，使得数移动时能跨过多个元素，则进行一次比较就可能消除多个元素交换。
D.L.shell于1959年在以他名字命名的排序算法中实现了这一思想。
算法先将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。
当增量减到1时，整个要排序的数被分成一组，排序完成。
排序类别时间复杂度稳定
插入排序O(n2)√
希尔排序O(n2)×
冒泡排序O(n2)√
选择排序O(n2)×
快速排序O(Nlogn)×
堆排序O(Nlogn)×
归并排序O(Nlogn)√。