各种排序的时间复杂度
基数排序时间复杂度公式详解
基数排序时间复杂度公式详解基数排序是一种非比较排序算法，它将数据按照位数逐个进行排序。
基数排序的时间复杂度取决于两个因素：数据量n和数据的位数d。
在本文中，我们将详细解释基数排序的时间复杂度公式，并分析其复杂度的变化情况。
我们来回顾一下基数排序的工作原理。
基数排序的核心思想是将待排序的数据按照位数分组，然后依次对每个位数进行排序。
具体的排序过程可以使用稳定的排序算法，如计数排序或桶排序。
通过多次排序，最终可以得到有序的结果。
在基数排序中，时间复杂度的计算需要考虑两个因素：数据量n和数据的位数d。
假设待排序的数据是n个数字，每个数字的位数是d。
那么基数排序的时间复杂度可以表示为O(d*(n+b))，其中b是数据的进制数。
我们来看位数d对时间复杂度的影响。
由于基数排序是按照位数逐个进行排序的，所以需要进行d次排序。
每次排序的时间复杂度是O(n+b)，其中n是待排序数据的数量，b是数据的进制数。
因此，位数d对时间复杂度的影响是线性的。
接下来，我们来看数据量n对时间复杂度的影响。
在每次排序中，需要对n个数字进行分组和排序。
分组的时间复杂度是O(n)，而排序的时间复杂度是O(b)。
因此，每次排序的时间复杂度是O(n+b)。
由于需要进行d次排序，所以总的时间复杂度是O(d*(n+b))。
我们来看数据的进制数b对时间复杂度的影响。
数据的进制数决定了每个位数的可能取值范围。
如果数据的进制数很大，那么每次排序中分组的时间复杂度就会增加。
因此，进制数b对时间复杂度的影响是线性的。
基数排序的时间复杂度公式为O(d*(n+b))，其中d是数据的位数，n是数据的数量，b是数据的进制数。
在实际应用中，通常会根据具体情况来选择数据的进制数和排序算法，以达到更好的排序效果。
需要注意的是，基数排序的时间复杂度公式并不考虑其他因素，如数据的分布情况和排序算法的优化。
在实际应用中，这些因素也会对排序的效率产生影响。
因此，在选择排序算法时，需要综合考虑数据的特点和排序的要求，来确定最适合的算法和参数。
各种排序的时间复杂度
排序算法所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
分类在计算机科学所使用的排序算法通常被分类为：计算的复杂度（最差、平均、和最好表现），依据串列（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!) 期望时间, 无穷的最坏情况。
快排最坏时间复杂度
快速排序的平均时间复杂度和最坏时间复杂度分别是O(nlgn)、O(n^2)。
当排序已经成为基本有序状态时，快速排序退化为O(n^2)，一般情况下，排序为指数复杂度。
快速排序最差情况递归调用栈高度O(n)，平均情况递归调用栈高度O(logn)，而不管哪种情况栈的每一层处理时间都是O(n)，所以，平均情况（最佳情况也是平均情况）的时间复杂度O(nlogn)，最差情况的时间复杂度为O(n^2)。
扩展资料
快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序，它采用了一种分治的策略，通常称其为分治法。
快速排序算法通过多次比较和交换来实现排序，其排序流程如下：
（1）首先设定一个分界值，通过该分界值将数组分成左右两部分。
（2）将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。
此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。
（3）然后，左边和右边的数据可以独立排序。
对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。
右侧的数组数据也可以做类似处理。
（4）重复上述过程，可以看出，这是一个递归定义。
通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。
当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。
排序—时间复杂度为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操作。
各种排序算法的时间复杂度和空间复杂度（阿里）
各种排序算法的时间复杂度和空间复杂度（阿⾥）⼆分查找法的时间复杂度：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. 时间复杂度在最坏情况下，二分归并排序的时间复杂度为O(nlogn)。
这是因为在每一层递归中，都需要将数组分解为两个规模近似相等的子数组，并且在每一层递归的最后都需要将这两个子数组合并起来。
可以通过递推式来进一步证明算法的时间复杂度。
3. 递推式分析我们可以通过递推式来分析二分归并排序的时间复杂度。
假设对规模为n的数组进行排序所需的时间为T(n)，则可以得到以下递推式：T(n) = 2T(n/2) +其中，T(n/2)表示对规模为n/2的子数组进行排序所需的时间表示将两个子数组合并所需的时间。
根据递推式的定义，我们可以得到二分归并排序的时间复杂度为O(nlogn)。
三、结论与个人观点通过以上分析，我们可以得出二分归并排序的时间复杂度为O(nlogn)。
这意味着该算法在最坏情况下也能保持较好的性能，适用于大规模数据的排序。
我个人认为，二分归并排序作为一种经典的排序算法，其时间复杂度的分析对于理解算法的工作原理和性能至关重要。
通过深入研究递推式，可以更加直观地理解算法的性能表现，为进一步优化算法提供了重要的参考依据。
四、总结在本文中，我们探讨了二分归并排序的时间复杂度，通过分析和递推式的方式深入理解了该算法的性能表现。
通过对时间复杂度的分析，我们对算法的性能有了更深入的认识，并且能够更好地理解算法在实际应用中的表现。
相信通过本文的阅读，读者能够对二分归并排序有更全面、深刻和灵活的理解。
【十大经典排序算法(动图演示)】 必学十大经典排序算法
【十大经典排序算法（动图演示）】必学十大经典排序算法0.1 算法分类十种常见排序算法可以分为两大类：比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。
非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。
0.2 算法复杂度0.3 相关概念稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
不稳定：如果a原本在b的前面，而a=b，排序之后a 可能会出现在b 的后面。
时间复杂度：对排序数据的总的操作次数。
反映当n变化时，操作次数呈现什么规律。
空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。
1、冒泡排序（Bubble Sort）冒泡排序是一种简单的排序算法。
它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。
走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
1.1 算法描述比较相邻的元素。
如果第一个比第二个大，就交换它们两个；对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；针对所有的元素重复以上的步骤，除了最后一个；重复步骤1~3，直到排序完成。
1.2 动图演示1.3 代码实现1.unction bubbleSort(arr) {2. varlen = arr.length;3. for(vari = 0; i arr[j+1]) {// 相邻元素两两对比6. vartemp = arr[j+1];// 元素交换7. arr[j+1] = arr[j];8. arr[j] = temp;9. }10. }11. }12. returnarr;13.}2、选择排序（Selection Sort）选择排序(Selection-sort)是一种简单直观的排序算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
不稳定排序算法可能会在相等的键值中改变纪录的相对次序，但是稳定排序算法从来不会如此。不稳定排序算法可以被特别地时作为稳定。作这件事情的一个方式是人工扩充键值的比较，如此在其他方面相同键值的两个物件间之比较，就会被决定使用在原先资料次序中的条目，当作一个同分决赛。然而，要记住这种次序通常牵涉到额外的空间负担。
当相等的元素是无法分辨的，比如像是整数，稳定度并不是一个问题。然而，假设以下的数对将要以他们的第一个数字来排序。
(4, 1) (3, 1) (3, 7) (5, 6)
在这个状况下，有可能产生两种不同的结果，一个是依照相等的键值维持相对的次序，而另外一个则没有：
(3, 1) (3, 7) (4, 1) (5, 6) (维持次序)
Stupid sort — O(n3); 递回版本需要 O(n2) 额外记忆体
Bead sort — O(n) or O(√n), 但需要特别的硬体
Pancake sorting — O(n), 但需要特别的硬体
排序的算法
排序的算法有很多，对空间的要求及其时间效率也不尽相同。下面列出了一些常见的排序算法。这里面插入排序和冒泡排序又被称作简单排序，他们对空间的要求不高，但是时间效率却不稳定；而后面三种排序相对于简单排序对空间的要求稍高一点，但时间效率却能稳定在很高的水平。基数排序是针对关键字在一个较小范围内的排序算法。
记忆体使用量（以及其他电脑资源的使用）
稳定度：稳定排序算法会依照相等的关键（换言之就是值）维持纪录的相对次序。也就是一个排序算法是稳定的，就是当有两个有相等关键的纪录R和S，且在原本的串列中R出现在S之前，在排序过的串列中R也将会是在S之前。
一般的方法：插入、交换、选择、合并等等。交换排序包含冒泡排序（bubble sort）和快速排序（quicksort）。选择排序包含shaker排序和堆排序（heapsort）。
看起来似乎堆排序与插入排序有些相像，但他们其实是本质不同的算法。至少，他们的时间复杂度差了一个数量级，一个是平方级的，一个是对数级的。
平均时间复杂度
插入排序 O(n2)
冒泡排序 O(n2)
选择排序 O(n2)
快速排序 O(n log n)
堆排序 O(n log n)
归并排序 O(n log n)
基数排序 O(n)
Introsort — O(n log n)
Patience sorting — O(n log n + k) 最外情况时间, 需要 额外的 O(n + k) 空间, 也需要找到最长的递增子序列（longest increasing subsequence）
不实用的排序算法
Bogo排序 — O(n × n!) 期望时间, 无穷的最坏情况。
设数组内存放了n个待排数字，数组下标从1开始，到n结束。
i=1
从数组的第i个元素开始到第n个元素，寻找最小的元素。
将上一步找到的最小元素和第i位元素交换。
如果i=n－1算法结束，否则回到第3步
选择排序的平均时间复杂度也是O(n²)的。
快速排序
现在开始，我们要接触高效排序算法了。实践证明，快速排序是所有排序算法中最高效的一种。它采用了分治的思想：先保证列表的前半部分都小于后半部分，然后分别对前半部分和后半部分排序，这样整个列表就有否与列表中数字间的比较次数有直接的关系，而"保证列表的前半部分都小于后半部分"就使得前半部分的任何一个数从此以后都不再跟后半部分的数进行比较了，大大减少了数字间不必要的比较。但查找数据得另当别论了。
排序算法
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
分类
在计算机科学所使用的排序算法通常被分类为：
计算的复杂度（最差、平均、和最好表现），依据串列（list）的大小（n）。一般而言，好的表现是O。(n log n)，且坏的行为是Ω(n2)。对於一个排序理想的表现是O(n)。仅使用一个抽象关键比较运算的排序算法总平均上总是至少需要Ω(n log n)。
堆排序
堆排序与前面的算法都不同，它是这样的：
首先新建一个空列表，作用与插入排序中的"有序列表"相同。
找到数列中最大的数字，将其加在"有序列表"的末尾，并将其从原数列中删除。
重复2号步骤，直至原数列为空。
堆排序的平均时间复杂度为nlogn,效率高（因为有堆这种数据结构以及它奇妙的特征，使得"找到数列中最大的数字"这样的操作只需要O(1)的时间复杂度，维护需要logn的时间复杂度），但是实现相对复杂（可以说是这里7种算法中比较难实现的）。
排列算法列表
在这个表格中，n是要被排序的纪录数量以及k是不同键值的数量。
稳定的
冒泡排序（bubble sort） — O(n2)
鸡尾酒排序 (Cocktail sort, 双向的冒泡排序) — O(n2)
插入排序（insertion sort）— O(n2)
桶排序 （bucket sort）— O(n); 需要 O(k) 额外 记忆体
不稳定
选择排序 （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) 最坏情况; 对於大的、乱数串列一般相信是最快的已知排序
计数排序 (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) 额外记忆体
插入排序
冒泡排序
选择排序
快速排序
堆排序
归并排序
基数排序
希尔排序
插入排序
插入排序是这样实现的：
首先新建一个空列表，用于保存已排序的有序数列（我们称之为"有序列表"）。
从原数列中取出一个数，将其插入"有序列表"中，使其仍旧保持有序状态。
重复2号步骤，直至原数列为空。
插入排序的平均时间复杂度为平方级的，效率不高，但是容易实现。它借助了"逐步扩大成果"的思想，使有序列表的长度逐渐增加，直至其长度等于原列表的长度。
希尔排序 O(n1.25)
鸽巢排序 (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 额外记忆体
冒泡排序
冒泡排序是这样实现的：
首先将所有待排序的数字放入工作列表中。
从列表的第一个数字到倒数第二个数字，逐个检查：若某一位上的数字大于他的下一位，则将它与它的下一位交换。
重复2号步骤，直至再也不能交换。
冒泡排序的平均时间复杂度与插入排序相同，也是平方级的，但也是非常容易实现的算法。
选择排序
选择排序是这样实现的：