快速排序图解gif（如何实现快速排序的方法）

本文目录

• 如何实现快速排序的方法
• 希尔排序图解流程图
• 如何理解《算法图解》中的快速排序算法
• 求C++快速排序、插入排序代码要超级详细，每步每个函数都要注析
• wps 列 排序
• 《算法图解》pdf
• 归并排序
• 十大经典算法之动图演示

如何实现快速排序的方法

快速排序法HTML5学堂-码匠：前几期“算法之旅”跟大家分享了冒泡排序法和选择排序法，它们都属于时间复杂度为O(n^2)的“慢”排序。今天跟大家分享多种排序算法里使用较广泛，速度快的排序算法 —— 快速排序法 。
Tips 1：关于“算法”及“排序”的基础知识，在此前“选择排序法”中已详细讲解，可点击文后的相关文章链接查看，在此不再赘述。
Tips 2：如果无特殊说明，本文的快速排序是从小到大的排序。
快速排序法的原理快速排序是一种划分交换排序，它采用分治的策略，通常称其为分治法。
分治法基本思想：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解决这些子问题，然后将这些子问题的结果组合成原问题的结果。
基本原理从序列中任选一个数作为“基准”；
所有小于“基准”的数，都挪到“基准”的左边；所有大于等于“基准”的数，都挪到“基准”的右边；
在这次移动结束之后，该“基准”就处于两个序列的中间位置，不再参与后续的排序；
针对“基准”左边和右边的两个子序列，不断重复上述步骤，直到所有子序列只剩下一个数为止。
原理图解现有一个序列为 ，如下演示快速排序法如何对其进行排序。
实现快速排序的步骤分解选择“基准”，并将其从原始数组分离先获取基准的索引值，再使用splice数组方法取出基准值。
Tips：该实例中， 基准的索引值 = parseInt（序列长度 / 2）
Tips：splice方法会改变原始数组。例如，arr = ;
遍历序列，拆分序列与“基准”比较大小，并拆分为两个子序列
小于“基准”的数存储于leftArr数组当中，大于等于“基准”的数存储于rightArr数组当中
Tips：当然，也可以将 小于等于“基准”的数存于leftArr，大于“基准”的数存于rightArr
由于要遍历序列，将每一个数与“基准”进行大小比较，所以，需要借助for语句来实现
递归调用，遍历子序列并组合子序列的结果定义一个函数，形参用于接收数组
function quickSort(arr) { };
实现递归调用遍历子序列，用concat数组方法组合子序列的结果
判断子序列的长度递归调用的过程中，子序列的长度等于1时，则停止递归调用，返回当前数组。
快速排序法完整代码
快速排序法的效率时间复杂度最坏情况：每一次选取的“基准”都是序列中最小的数/最大的数，这种情况与冒泡排序法类似（每一次只能确定一个数的顺序），时间复杂度为O（n^2）
最好情况：每一次选取的“基准”都是序列中最中间的一个数（是中位数，而不是位置上的中间），那么每次都把当前序列划分成了长度相等的两个子序列。这时候，第一次就有n/2、n/2两个子序列，第二次就有n/4、n/4、n/4、n/4四个子序列，依此类推，n个数一共需要logn次才能排序完成（2^x=n，x=logn），然后每次都是n的复杂度，时间复杂度为O（n logn）
空间复杂度最坏情况：需要进行n_1 次递归调用，其空间复杂度为 O（n）
最好情况：需要logn次递归调用，其空间复杂度为O（logn）
算法的稳定性快速排序是一种不稳定排序算法
例如：现有序列为，“基准”数字选择为第二个1
在第一轮比较之后，变成了（右序列的1是此前的第一个1）
不难发现，原序列的两个1的先后顺序被破坏了，改变了先后顺序，自然就是“不稳定”的排序算法了
关于O在此前的“冒泡排序法”一文当中，我们详细讲解过O是什么，在此就不多说了，直接上图吧

希尔排序图解流程图

.example-btn{color:#fff;background-color:#5cb85c;border-color:#4cae4c}.example-btn:hover{color:#fff;background-color:#47a447;border-color:#398439}.example-btn:active{background-image:none}div.example{width:98%;color:#000;background-color:#f6f4f0;background-color:#d0e69c;background-color:#dcecb5;background-color:#e5eecc;margin:0 0 5px 0;padding:5px;border:1px solid #d4d4d4;background-image:-webkit-linear-gradient(#fff,#e5eecc 100px);background-image:linear-gradient(#fff,#e5eecc 100px)}div.example_code{line-height:1.4em;width:98%;background-color:#fff;padding:5px;border:1px solid #d4d4d4;font-size:110%;font-family:Menlo,Monaco,Consolas,"Andale Mono","lucida console","Courier New",monospace;word-break:break-all;word-wrap:break-word}div.example_result{background-color:#fff;padding:4px;border:1px solid #d4d4d4;width:98%}div.code{width:98%;border:1px solid #d4d4d4;background-color:#f6f4f0;color:#444;padding:5px;margin:0}div.code div{font-size:110%}div.code div,div.code p,div.example_code p{font-family:"courier new"}pre{margin:15px auto;font:12px/20px Menlo,Monaco,Consolas,"Andale Mono","lucida console","Courier New",monospace;white-space:pre-wrap;word-break:break-all;word-wrap:break-word;border:1px solid #ddd;border-left-width:4px;padding:10px 15px} 排序算法是《数据结构与算法》中最基本的算法之一。排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。以下是希尔排序算法：

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：
插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率； 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；
希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。
1. 算法步骤
选择一个增量序列 t1，t2，……，tk，其中 ti 》 tj, tk = 1；

按增量序列个数 k，对序列进行 k 趟排序；

每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
2. 动图演示

代码实现 JavaScript 实例 function shellSort ( arr ) {
    var len = arr. length ,
        temp ,
        gap = 1 ;
    while ( gap 0 ; gap = Math . floor ( gap / 3 ) ) {
        for ( var i = gap ; i = 0 && arr 》 temp ; j -= gap ) {
                arr ;
            }
            arr = temp ;
        }
    }
    return arr ;
}
Python 实例 def shellSort ( arr ) :
    import math
    gap = 1
    while ( gap 0 :
        for i in range ( gap , len ( arr ) ) :
            temp = arr
            j = i-gap
            while j 》= 0 and arr 》 temp:
                arr
                j- = gap
            arr = temp
        gap = math . floor ( gap/ 3 )
    return arr
Go 实例 func shellSort ( arr int {
        length := len ( arr )
        gap := 1
        for gap 《 length / 3 {
                gap = gap * 3 + 1
        }
        for gap 》 0 {
                for i := gap ; i 《 length ; i ++ {
                        temp := arr
                        j := i - gap
                        for j 》 = 0 && arr 》 temp {
                                arr
                                j -= gap
                        }
                        arr = temp
                }
                gap = gap / 3
        }
        return arr
}
Java 实例 public static void shellSort ( int arr ) {
    int length = arr. length ;
    int temp ;
    for ( int step = length / 2 ; step 》= 1 ; step /= 2 ) {
        for ( int i = step ; i = 0 && arr 》 temp ) {
                arr ;
                j -= step ;
            }
            arr = temp ;
        }
    }
}
PHP 实例 function shellSort ( $arr )
{
    $len = count ( $arr ) ;
    $temp = 0 ;
    $gap = 1 ;
    while ( $gap 0 ; $gap = floor ( $gap / 3 ) ) {
        for ( $i = $gap ; $i = 0 && $arr 》 $temp ; $j -= $gap ) {
                $arr ;
            }
            $arr = $temp ;
        }
    }
    return $arr ;
}
C 实例 void shell_sort ( int arr , int len ) {
        int gap , i , j ;
        int temp ;
        for ( gap = len 》》 1 ; gap 》 0 ; gap 》》= 1 )
                for ( i = gap ; i = 0 && arr 》 temp ; j -= gap )
                                arr ;
                        arr = temp ;
                }
}
C++ 实例 template
void shell_sort ( T array , int length ) {
    int h = 1 ;
    while ( h = 1 ) {
        for ( int i = h ; i = h && array = tmp; } gap /= 3; } } 以上为希尔排序算法详细介绍，插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等排序算法各有优缺点，用一张图概括：
关于时间复杂度

平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。

线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序；

O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。 希尔排序

线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。

关于稳定性

稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。

不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。

名词解释：

n：数据规模

k："桶"的个数

In-place：占用常数内存，不占用额外内存

Out-place：占用额外内存

稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同

如何理解《算法图解》中的快速排序算法

快速排序的基本思想就是从一个数组中任意挑选一个元素（通常来说会选择最左边的元素）作为中轴元素，将剩下的元素以中轴元素作为比较的标准，将小于等于中轴元素的放到中轴元素的左边，将大于中轴元素的放到中轴元素的右边。

然后以当前中轴元素的位置为界，将左半部分子数组和右半部分子数组看成两个新的数组，重复上述操作，直到子数组的元素个数小于等于1（因为一个元素的数组必定是有序的）。

以下的代码中会常常使用交换数组中两个元素值的Swap方法，其代码如下

public static void Swap(int A, int i, int j){

int tmp;

tmp = A;

A;

A = tmp;

扩展资料：

快速排序算法 的基本思想是：将所要进行排序的数分为左右两个部分，其中一部分的所有数据都比另外一 部分的数据小，然后将所分得的两部分数据进行同样的划分，重复执行以上的划分操作，直 到所有要进行排序的数据变为有序为止。

定义两个变量low和high，将low、high分别设置为要进行排序的序列的起始元素和最后一个元素的下标。第一次，low和high的取值分别为0和n-1，接下来的每次取值由划分得到的序列起始元素和最后一个元素的下标来决定。

定义一个变量key，接下来以key的取值为基准将数组A划分为左右两个部分，通 常，key值为要进行排序序列的第一个元素值。第一次的取值为A，以后毎次取值由要划 分序列的起始元素决定。

从high所指向的数组元素开始向左扫描，扫描的同时将下标为high的数组元素依次与划分基准值key进行比较操作，直到high不大于low或找到第一个小于基准值key的数组元素，然后将该值赋值给low所指向的数组元素，同时将low右移一个位置。

如果low依然小于high，那么由low所指向的数组元素开始向右扫描，扫描的同时将下标为low的数组元素值依次与划分的基准值key进行比较操作，直到low不小于high或找到第一个大于基准值key的数组元素，然后将该值赋给high所指向的数组元素，同时将high左移一个位置。

重复步骤(3) (4)，直到low的植不小于high为止，这时成功划分后得到的左右两部分分别为A，其中，pos下标所对应的数组元素的值就是进行划分的基准值key，所以在划分结束时还要将下标为pos的数组元素赋值 为 key。

求C++快速排序、插入排序代码要超级详细，每步每个函数都要注析

sort()//快速排序

STL库 algorithm库

快速排序（升序）：

类似二分，找到任意点（一般是序列中点）

然后把小于中点的放到左边，大于的放到右边

之后，在以同样方法排左右区间（递归）

代码：

#include《iostream》
#include《cstring》
using namespace std;
int a;
void q_sort(int s,int e)
{
int m=a,l=s,r=e;
do
{
while(a《m)l++;
while(a》m)r--;
if(l《=r)
{
swap(a);
l++;
r--;
}
}while(l《=r);
if(l《e)
q_sort(l,e);
if(r》l)
q_sort(l,r);
}
int main()
{
int n;
cin》》n;
for(int i=1;i《=n;i++)
cin》》a;
q_sort(1,n);
for(int i=1;i《=n;i++)
cout《《a《《" ";
return 0;
}

wps 列 排序

你好
给老板报表前，最好先给它排个序，让关键信息优先展示在最前面。Excel/WPS表格中的数据可以按照多种方式排列，如数值大小、颜色、倒序、随机顺序、笔画多少、自创序列等。这一篇文章将一一用GIF动图演示如何按照这些方式排序。
排序基础
排序的基本方法是：选中数据，点击“数据”——“排序”，确定是否要勾选“数据包含标题”选项，然后选择关键字（也就是列号或标题），选择排序依据（最常用的是“数值”），然后选择次序（升序、降序、自定义序列），最后点击“确定”即可。
快速排序的方法：点击关键字所在列，接着点击“A-Z”/“Z-A”排序按钮，即可实现按照该列数值大小升序/降序排列。
倒序排序
倒序排序非常简单，添加一个辅助列，填充数字“1，2，3……”，然后按照这些数字降序排列就可以了。
随机排序
和倒序排序差不多，添加一个辅助列，输入函数“=rand()”，然后按照这些随机数排序即可。
按照笔画多少排序
选中数据，点击“排序”，设置为按照“姓名”——“数值”——“升序”排列，点击“选项”，选择按照“笔画排序”。最终，数据会按照姓氏笔画的由少到多进行排列。
按颜色排序
将排序依据设置为“单元格颜色”，然后选择哪种颜色显示在顶端/底端。一般在单元格中设置了条件格式后，又希望将有颜色的单元格放在最前面时，会使用按颜色排序。
多条件排序
打开排序窗口后，点击“添加条件”设置更多的规则即可。表格首先会按照你设置的第一个规则进行排序，然后在按照第二个规则进行排序。
自定义排序
默认的排序次序只有升序和降序，有时候需要按照天干地支、部门、学历排序，或者领导就想看“白易、冰兰、元柏、若烟”这几位员工的表现。这时就可以在排序窗口中选择“自定义序列”——输入自创序列，录入员工名字，然后选择按照这个序列排序即可。
部分区域排序
排序前，选中一部分数据，排序时不要扩展区域就可以只对这部分数据进行排序。
按行排序
不必使用“转置”，在排序窗口中点击“选项”——“按行排序”，然后按照第几行进行排序即可。
注意
软件会记住你上一次的排序规则，因此需要多次排序时，一定要打开排序窗口检查规则。
在排序前，添加一个序号列，是一个好习惯。当你多次排列后，若对效果不满意，可以按照这个序号列快速恢复原来的表格。
特别注意排序前一定不要多选或少选数据。
排序的意义除了可以让最重要的数据排在最前面，还可以辅助你做很多的事情，例如利用排序可以批量隔行插入空行，也可以将奇数行和偶数行拆分开。

《算法图解》pdf

本书示例丰富，图文并茂，以让人容易理解的方式阐释了算法，旨在帮助程序员在日常项目中更好地发挥算法的能量。书中的前三章将帮助你打下基础，带你学习二分查找、大O表示法、两种基本的数据结构以及递归等。余下的篇幅将主要介绍应用广泛的算法，具体内容包括：面对具体问题时的解决技巧，比如，何时采用贪婪算法或动态规划；散列表的应用；图算法；Kzui近邻算法。

目录
前言
致谢
关于本书
第1　章 算法简介　1
1．1　引言　1
1．1．1　性能方面　1
1．1．2　问题解决技巧　2
1．2　二分查找　2
1．2．1　更佳的查找方式　4
1．2．2　运行时间　8
1．3　大O 表示法　8
1．3．1　算法的运行时间以不同的速度增加　9
1．3．2　理解不同的大O运行时间　10
1．3．3　大O 表示法指出了最糟情况下的运行时间　12
1．3．4　一些常见的大O运行时间　12
1．3．5　旅行商　13
1．4　小结　15
第2　章 选择排序　16
2．1　内存的工作原理　16
2．2　数组和链表　18
2．2．1　链表　19
2．2．2　数组　20
2．2．3　术语　21
2．2．4　在中间插入　22
2．2．5　删除　23
2．3　选择排序　25
2．4　小结　28
第3　章 递归　29
3．1　递归　29
3．2　基线条件和递归条件　32
3．3　栈　33
3．3．1　调用栈　34
3．3．2　递归调用栈　36
3．4　小结　40
第4　章 快速排序　41
4．1　分而治之　41
4．2　快速排序　47
4．3　再谈大O表示法　52
4．3．1　比较合并排序和快速排序　53
4．3．2　平均情况和最糟情况　54
4．4　小结　57
第5　章 散列表　58
5．1　散列函数　60
5．2　应用案例　63
5．2．1　将散列表用于查找　63
5．2．2　防止重复　64
5．2．3　将散列表用作缓存　66
5．2．4　小结　68
5．3　冲突　69
5．4　性能　71
5．4．1　填装因子　72
5．4．2　良好的散列函数　74
5．5　小结　75
第6　章 广度优先搜索　76
6．1　图简介　77
6．2　图是什么　79
6．3　广度优先搜索　79
6．3．1　查找最短路径　82
6．3．2　队列　83
6．4　实现图　84
6．5　实现算法　86
6．6　小结　93
第7　章 狄克斯特拉算法　94
7．1　使用狄克斯特拉算法　95
7．2　术语　98
7．3　换钢琴　100
7．4　负权边　105
7．5　实现　108
7．6　小结　116
第8　章 贪婪算法　117
8．1　教室调度问题　117
8．2　背包问题　119
8．3　集合覆盖问题　121
8．4　NP 完全问题　127
8．4．1　旅行商问题详解　127
8．4．2　如何识别NP 完全问题　131
8．5　小结　133
第9　章 动态规划　134
9．1　背包问题　134
9．1．1　简单算法　135
9．1．2　动态规划　136
9．2　背包问题FAQ　143
9．2．1　再增加一件商品将如何呢　143
9．2．2　行的排列顺序发生变化时结果将如何　145
9．2．3　可以逐列而不是逐行填充网格吗　146
9．2．4　增加一件更小的商品将如何呢　146
9．2．5　可以偷商品的一部分吗　146
9．2．6　旅游行程最优化　147
9．2．7　处理相互依赖的情况　148
9．2．8　计算最终的解时会涉及两个以上的子背包吗　148
9．2．9　最优解可能导致背包没装满吗　149
9．3　最长公共子串　149
9．3．1　绘制网格　150
9．3．2　填充网格　151
9．3．3　揭晓答案　152
9．3．4　最长公共子序列　153
9．3．5　最长公共子序列之解决方案　154
9．4　小结　155
第10　章 K 最近邻算法　156
10．1　橙子还是柚子　156
10．2　创建推荐系统　158
10．2．1　特征抽取　159
10．2．2　回归　162
10．2．3　挑选合适的特征　164
10．3　机器学习简介　165
10．3．1　OCR　165
10．3．2　创建垃圾邮件过滤器　166
10．3．3　预测股票市场　167
10．4　小结　167
第11　章 接下来如何做　168
11．1　树　168
11．2　反向索引　171
11．3　傅里叶变换　171
11．4　并行算法　172
11．5　MapReduce　173
11．5．1　分布式算法为何很有用　173
11．5．2　映射函数　173
11．5．3　归并函数　174
11．6　布隆过滤器和HyperLogLog　174
11．6．1　布隆过滤器　175
11．6．2　HyperLogLog　176
11．7　SHA 算法　176
11．7．1　比较文件　177
11．7．2　检查密码　178
11．8　局部敏感的散列算法　178
11．9　Diffie-Hellman 密钥交换　179
11．10　线性规划　180
11．11　结语　180
练习答案　181

最后，这里为大家准备了几百本的互联网电子书，有需要的过来取吧。 点击获取

归并排序

先考虑一个简单的问题：如何在线性的时间内将两个有序队列合并为一个有序队列（并输出）？
A队列：1 3 5 7 9
B队列：1 2 7 8 9
看上面的例子，AB两个序列都是已经有序的了。在给出数据已经有序的情况下，我们会发现很多神奇的事，比如，我们将要输出的第一个数一定来自于这两个序列各自最前面的那个数。两个数都是1，那么我们随便取出一个（比如A队列的那个1）并输出：
A队列：1 3 5 7 9
B队列：1 2 7 8 9
输出：1
注意，我们取出了一个数，在原数列中删除这个数。删除操作是通过移动队首指针实现的，否则复杂度就高了。
现在，A队列打头的数变成3了，B队列的队首仍然是1。此时，我们再比较3和1哪个大并输出小的那个数：
A队列：1 3 5 7 9
B队列：1 2 7 8 9
输出：1 1
接下来的几步如下：
A队列：1 3 5 7 9 A队列：1 3 5 7 9 A队列：1 3 5 7 9 A队列：1 3 5 7 9
B队列：1 2 7 8 9 ==》 B队列：1 2 7 8 9 ==》 B队列：1 2 7 8 9 ==》 B队列：1 2 7 8 9 ……
输出：1 1 2 输出：1 1 2 3 输出：1 1 2 3 5 输出：1 1 2 3 5 7
我希望你明白了这是怎么做的。这个做法显然是正确的，复杂度显然是线性。
归并排序(Merge Sort)将会用到上面所说的合并操作。给出一个数列，归并排序利用合并操作在O(nlogn)的时间内将数列从小到大排序。归并排序用的是分治(Divide and Conquer)的思想。首先我们把给出的数列平分为左右两段，然后对两段数列分别进行排序，最后用刚才的合并算法把这两段（已经排过序的）数列合并为一个数列。有人会问“对左右两段数列分别排序时用的什么排序”么？答案是：用归并排序。也就是说，我们递归地把每一段数列又分成两段进行上述操作。你不需要关心实际上是怎么操作的，我们的程序代码将递归调用该过程直到数列不能再分（只有一个数）为止。
初看这个算法时有人会误以为时间复杂度相当高。我们下面给出的一个图将用非递归的眼光来看归并排序的实际操作过程，供大家参考。我们可以借助这个图证明，归并排序算法的时间复杂度为O(nlogn)。
\ / \ / \ / \ /
\ / \ /

\ /

上图中的每一个“ \ / ”表示的是上文所述的线性时间合并操作。上图用了4行来图解归并排序。如果有n个数，表示成上图显然需要O(logn)行。每一行的合并操作复杂度总和都是O(n)，那么logn行的总复杂度为O(nlogn)。这相当于用递归树的方法对归并排序的复杂度进行了分析。假设，归并排序的复杂度为T(n)，T(n)由两个T(n/2)和一个关于n的线性时间组成，那么T(n)=2*T(n/2)+O(n)。不断展开这个式子我们可以同样可以得到T(n)=O(nlogn)的结论，你可以自己试试。如果你能在线性的时间里把分别计算出的两组不同数据的结果合并在一起，根据T(n)=2*T(n/2)+O(n)=O(nlogn)，那么我们就可以构造O(nlogn)的分治算法。这个结论后面经常用。我们将在计算几何部分举一大堆类似的例子。
如果你第一次见到这么诡异的算法，你可能会对这个感兴趣。分治是递归的一种应用。这是我们第一次接触递归运算。下面说的快速排序也是用的递归的思想。递归程序的复杂度分析通常和上面一样，主定理(Master Theory)可以简化这个分析过程。主定理和本文内容离得太远，我们以后也不会用它，因此我们不介绍它，大家可以自己去查。有个名词在这里的话找学习资料将变得非常容易，我最怕的就是一个东西不知道叫什么名字，半天找不到资料。
归并排序有一个有趣的副产品。利用归并排序能够在O(nlogn)的时间里计算出给定序列里逆序对的个数。你可以用任何一种平衡二叉树来完成这个操作，但用归并排序统计逆序对更方便。我们讨论逆序对一般是说的一个排列中的逆序对，因此这里我们假设所有数不相同。假如我们想要数1, 6, 3, 2, 5, 4中有多少个逆序对，我们首先把这个数列分为左右两段。那么一个逆序对只可能有三种情况：两个数都在左边，两个数都在右边，一个在左一个在右。在左右两段分别处理完后，线性合并的过程中我们可以顺便算出所有第三种情况的逆序对有多少个。换句话说，我们能在线性的时间里统计出A队列的某个数比B队列的某个数大有多少种情况。
A队列：1 3 6 A队列：1 3 6 A队列：1 3 6 A队列：1 3 6 A队列：1 3 6
B队列：2 4 5 ==》 B队列：2 4 5 ==》 B队列：2 4 5 ==》 B队列：2 4 5 ==》 B队列：2 4 5 ……
输出： 输出：1 输出：1 2 输出：1 2 3 输出：1 2 3 4
每一次从B队列取出一个数时，我们就知道了在A队列中有多少个数比B队列的这个数大，它等于A队列现在还剩的数的个数。比如，当我们从B队列中取出2时，我们同时知道了A队列的3和6两个数比2大。在合并操作中我们不断更新A队列中还剩几个数，在每次从B队列中取出一个数时把当前A队列剩的数目加进最终答案里。这样我们算出了所有“大的数在前一半，小的数在后一半”的情况，其余情况下的逆序对在这之前已经被递归地算过了。
============================华丽的分割线============================
堆排序(Heap Sort)利用了堆(Heap)这种数据结构（什么是堆？）。堆的插入操作是平均常数的，而删除一个根节点需要花费O(log n)的时间。因此，完成堆排序需要线性时间建立堆（把所有元素依次插入一个堆），然后用总共O(nlogn)的时间不断取出最小的那个数。只要堆会搞，堆排序就会搞。堆在那篇日志里有详细的说明，因此这里不重复说了。
============================华丽的分割线============================
快速排序(Quick Sort)也应用了递归的思想。我们想要把给定序列分成两段，并对这两段分别进行排序。一种不错的想法是，选取一个数作为“关键字”，并把其它数分割为两部分，把所有小于关键字的数都放在关键字的左边，大于关键字的都放在右边，然后递归地对左边和右边进行排序。把该区间内的所有数依次与关键字比较，我们就可以在线性的时间里完成分割的操作。完成分割操作有很多有技巧性的实现方法，比如最常用的一种是定义两个指针，一个从前往后找找到比关键字大的，一个从后往前找到比关键字小的，然后两个指针对应的元素交换位置并继续移动指针重复刚才的过程。这只是大致的方法，具体的实现还有很多细节问题。快速排序是我们最常用的代码之一，网上的快速排序代码五花八门，各种语言，各种风格的都有。大家可以随便找一个来看看，我说过了我们讲算法但不讲如何实现。NOIp很简单，很多人NOIp前就背了一个快速排序代码就上战场了。当时我把快速排序背完了，抓紧时间还顺便背了一下历史，免得晚上听写又不及格。
不像归并排序，快速排序的时间复杂度很难计算。我们可以看到，归并排序的复杂度最坏情况下也是O(nlogn)的，而快速排序的最坏情况是O(n^2)的。如果每一次选的关键字都是当前区间里最大（或最小）的数，那么这样将使得每一次的规模只减小一个数，这和插入排序、选择排序等平方级排序没有区别。这种情况不是不可能发生。如果你每次选择关键字都是选择的该区间的第一个数，而给你的数据恰好又是已经有序的，那你的快速排序就完蛋了。显然，最好情况是每一次选的数正好就是中位数，这将把该区间平分为两段，复杂度和前面讨论的归并排序一模一样。根据这一点，快速排序有一些常用的优化。比如，我们经常从数列中随机取一个数当作是关键字（而不是每次总是取固定位置上的数），从而尽可能避免某些特殊的数据所导致的低效。更好的做法是随机取三个数并选择这三个数的中位数作为关键字。而对三个数的随机取值反而将花费更多的时间，因此我们的这三个数可以分别取数列的头一个数、末一个数和正中间那个数。另外，当递归到了一定深度发现当前区间里的数只有几个或十几个时，继续递归下去反而费时，不如返回插入排序后的结果。这种方法同时避免了当数字太少时递归操作出错的可能。
下面我们证明，快速排序算法的平均复杂度为O(nlogn)。不同的书上有不同的解释方法，这里我选用算法导论上的讲法。它更有技巧性一些，更有趣一些，需要转几个弯才能想明白。
看一看快速排序的代码。正如我们提到过的那种分割方法，程序在经过若干次与关键字的比较后才进行一次交换，因此比较的次数比交换次数更多。我们通过证明一次快速排序中元素之间的比较次数平均为O(nlogn)来说明快速排序算法的平均复杂度。证明的关键在于，我们需要算出某两个元素在整个算法过程中进行过比较的概率。
我们举一个例子。假如给出了1到10这10个数，第一次选择关键字7将它们分成了{1,2,3,4,5,6}和{8,9,10}两部分，递归左边时我们选择了3作为关键字，使得左部分又被分割为{1,2}和{4,5,6}。我们看到，数字7与其它所有数都比较过一次，这样才能实现分割操作。同样地，1到6这6个数都需要与3进行一次比较（除了它本身之外）。然而，3和9决不可能相互比较过，2和6也不可能进行过比较，因为第一次出现在3和9，2和6之间的关键字把它们分割开了。也就是说，两个数A(i)和A(j)比较过，当且仅当第一个满足A(i)《=x《=A(j)的关键字x恰好就是A(i)或A(j) （假设A(i)比A(j)小）。我们称排序后第i小的数为Z(i)，假设i《j，那么第一次出现在Z(i)和Z(j)之间的关键字恰好就是Z(i)或Z(j)的概率为2/(j-i+1)，这是因为当Z(i)和Z(j)之间还不曾有过关键字时，Z(i)和Z(j)处于同一个待分割的区间，不管这个区间有多大，不管递归到哪里了，关键字的选择总是随机的。我们得到，Z(i)和Z(j)在一次快速排序中曾经比较过的概率为2/(j-i+1)。
现在有四个数，2,3,5,7。排序时，相邻的两个数肯定都被比较过，2和5、3和7都有2/3的概率被比较过，2和7之间被比较过有2/4的可能。也就是说，如果对这四个数做12次快速排序，那么2和3、3和5、5和7之间一共比较了12*3=36次，2和5、3和7之间总共比较了8*2=16次，2和7之间平均比较了6次。那么，12次排序中总的比较次数期望值为36+16+6=58。我们可以计算出单次的快速排序平均比较了多少次：58/12=29/6。其实，它就等于6项概率之和，1+1+1+2/3+2/3+2/4=29/6。这其实是与期望值相关的一个公式。
同样地，如果有n个数，那么快速排序平均需要的比较次数可以写成下面的式子。令k=j-i，我们能够最终得到比较次数的期望值为O(nlogn)。

这里用到了一个知识：1+1/2+1/3+...+1/n与log n增长速度相同，即∑(1/n)=Θ(log n)。它的证明放在本文的最后。
在三种O(nlogn)的排序算法中，快速排序的理论复杂度最不理想，除了它以外今天说的另外两种算法都是以最坏情况O(nlogn)的复杂度进行排序。但实践上看快速排序效率最高（不然为啥叫快速排序呢），原因在于快速排序的代码比其它同复杂度的算法更简洁，常数时间更小。
快速排序也有一个有趣的副产品：快速选择给出的一些数中第k小的数。一种简单的方法是使用上述任一种O(nlogn)的算法对这些数进行排序并返回排序后数组的第k个元素。快速选择(Quick Select)算法可以在平均O(n)的时间完成这一操作。它的最坏情况同快速排序一样，也是O(n^2)。在每一次分割后，我们都可以知道比关键字小的数有多少个，从而确定了关键字在所有数中是第几小的。我们假设关键字是第m小。如果k=m，那么我们就找到了答案——第k小元素即该关键字。否则，我们递归地计算左边或者右边：当k《m时，我们递归地寻找左边的元素中第k小的；当k》m时，我们递归地寻找右边的元素中第k-m小的数。由于我们不考虑所有的数的顺序，只需要递归其中的一边，因此复杂度大大降低。复杂度平均线性，我们不再具体证了。
还有一种算法可以在最坏O(n)的时间里找出第k小元素。那是我见过的所有算法中最没有实用价值的算法。那个O(n)只有理论价值。
============================华丽的分割线============================
我们前面证明过，仅仅依靠交换相邻元素的操作，复杂度只能达到O(n^2)。于是，人们尝试交换距离更远的元素。当人们发现O(nlogn)的排序算法似乎已经是极限的时候，又是什么制约了复杂度的下界呢？我们将要讨论的是更底层的东西。我们仍然假设所有的数都不相等。
我们总是不断在数与数之间进行比较。你可以试试，只用4次比较绝对不可能给4个数排出顺序。每多进行一次比较我们就又多知道了一个大小关系，从4次比较中一共可以获知4个大小关系。4个大小关系共有2^4=16种组合方式，而4个数的顺序一共有4!=24种。也就是说，4次比较可能出现的结果数目不足以区分24种可能的顺序。更一般地，给你n个数叫你排序，可能的答案共有n!个，k次比较只能区分2^k种可能，于是只有2^k》=n!时才有可能排出顺序。等号两边取对数，于是，给n个数排序至少需要log2(n!)次。注意，我们并没有说明一定能通过log2(n!)次比较排出顺序。虽然2^5=32超过了4!，但这不足以说明5次比较一定足够。如何用5次比较确定4个数的大小关系还需要进一步研究。第一次例外发生在n=12的时候，虽然2^29》12!，但现已证明给12个数排序最少需要30次比较。我们可以证明log(n!)的增长速度与nlogn相同，即log(n!)=Θ(nlogn)。这是排序所需要的最少的比较次数，它给出了排序复杂度的一个下界。log(n!)=Θ(nlogn)的证明也附在本文最后。
这篇日志的第三题中证明log2(N)是最优时用到了几乎相同的方法。那种“用天平称出重量不同的那个球至少要称几次”一类题目也可以用这种方法来解决。事实上，这里有一整套的理论，它叫做信息论。信息论是由香农(Shannon)提出的。他用对数来表示信息量，用熵来表示可能的情况的随机性，通过运算可以知道你目前得到的信息能够怎样影响最终结果的确定。如果我们的信息量是以2为底的，那信息论就变成信息学了。从根本上说，计算机的一切信息就是以2为底的信息量(bits=binary digits)，因此我们常说香农是数字通信之父。信息论和热力学关系密切，比如熵的概念是直接从热力学的熵定义引申过来的。和这个有关的东西已经严重偏题了，这里不说了，有兴趣可以去看《信息论与编码理论》。我对这个也很有兴趣，半懂不懂的，很想了解更多的东西，有兴趣的同志不妨加入讨论。物理学真的很神奇，利用物理学可以解决很多纯数学问题，我有时间的话可以举一些例子。我他妈的为啥要选文科呢。
后面将介绍的三种排序是线性时间复杂度，因为，它们排序时根本不是通过互相比较来确定大小关系的。
附1：∑(1/n)=Θ(log n)的证明
首先我们证明，∑(1/n)=O(log n)。在式子1+1/2+1/3+1/4+1/5+...中，我们把1/3变成1/2，使得两个1/2加起来凑成一个1；再把1/5,1/6和1/7全部变成1/4，这样四个1/4加起来又是一个1。我们把所有1/2^k的后面2^k-1项全部扩大为1/2^k，使得这2^k个分式加起来是一个1。现在，1+1/2+...+1/n里面产生了几个1呢？我们只需要看小于n的数有多少个2的幂即可。显然，经过数的扩大后原式各项总和为log n。O(logn)是∑(1/n)的复杂度上界。
然后我们证明，∑(1/n)=Ω(log n)。在式子1+1/2+1/3+1/4+1/5+...中，我们把1/3变成1/4，使得两个1/4加起来凑成一个1/2；再把1/5,1/6和1/7全部变成1/8，这样四个1/8加起来又是一个1/2。我们把所有1/2^k的前面2^k-1项全部缩小为1/2^k，使得这2^k个分式加起来是一个1/2。现在，1+1/2+...+1/n里面产生了几个1/2呢？我们只需要看小于n的数有多少个2的幂即可。显然，经过数的缩小后原式各项总和为1/2*logn。Ω(logn)是∑(1/n)的复杂度下界。
附2：log(n!)=Θ(nlogn)的证明
首先我们证明，log(n!)=O(nlogn)。显然n!《n^n，两边取对数我们得到log(n!)《log(n^n)，而log(n^n)就等于nlogn。因此，O(nlogn)是log(n!)的复杂度上界。
然后我们证明，log(n!)=Ω(nlogn)。n!=n(n-1)(n-2)(n-3)....1，把前面一半的因子全部缩小到n/2，后面一半因子全部舍去，显然有n!》(n/2)^(n/2)。两边取对数，log(n!)》(n/2)log(n/2)，后者即Ω(nlogn)。因此，Ω(nlogn)是log(n!)的复杂度下界。
今天写到这里了，大家帮忙校对哦
Matrix67原创
转贴请注明出处

十大经典算法之动图演示

前面好奇心已经带大家从 冒泡排序 开始，一直到 基数排序 ，从头过了一遍，那么这里归纳一下，将 十个经典算法 的 演示图 都放出来，供大家对比参考学习。

每张图都会附带详细 解说链接 ，有需要的同学可以 点击详细了解学习 。

Python 实现经典算法之冒泡排序

Python 实现经典算法之选择排序

Python 实现经典算法之插入排序

Python 实现经典算法之希尔排序

Python 实现经典算法之归并排序

Python 实现经典算法之堆排序

Python 实现经典算法之快速排序

Python 实现经典算法之计数排序

Python 实现经典算法之桶排序

Python 实现经典算法之基数排序

好了，上面就是 经典十大排序算法 的图片演示了，我 尽可能 的都是放了动图。

部分文章里面可能不止一张图片，我这里碍于篇幅和排版，就没放。有需要的同学也可以 点击 附带的 链接 详细 学习