算法对比：

算法	时间复杂度	适合场景
冒泡排序、插入排序、选择排序	O(n2)	小规模数据
归并排序、快速排序	O(nlogn）	大规模数据

归并排序和快速排序都用到了分治思想，非常巧妙。我们可以借鉴这个思想，来解决非排序的问题，比如：如何在 O(n) 的时间复杂度内查找一个无序数组中的第 K 大元素？

归并排序

使用分治思想：大问题分解为小问题，分而治之，小问题解决了，大问题也就解决了。

归并排序的递推公式:

递推公式
merger_sort(p..r) = merge(merger_sort(p..q),merger_sort(q+1..r))
终止条件
p>=r 不再继续分解

归并排序的伪代码

merge_sort(A,n){merge_sort_c(A,0,n-1)
}
merge_sort_c(A,p,r){if p >= r  then returnq = (p+r)/2;//分治递归merge_sort_c(A,p,q)merge_sort_c(A,q+1,r)//合并merge(A[p...r],A[p...q],A[q+1...r])}

merge（）函数的实现思路：

申请一个临时数组 tmp，大小与 A[p...r]相同。我们用两个游标 i 和 j，分别指向 A[p...q]和 A[q+1...r]的第一个元素。比较这两个元素 A[i]和 A[j]，如果 A[i]<=A[j]，就把 A[i]放入到临时数组 tmp，并且 i 后移一位，否则将 A[j]放入到数组 tmp，j 后移一位。继续上述比较过程，直到其中一个子数组中的所有数据都放入临时数组中，再把另一个数组中的数据依次加入到临时数组的末尾，这个时候，临时数组中存储的就是两个子数组合并之后的结果了。最后再把临时数组 tmp 中的数据拷贝到原数组 A[p...r]中。

merge函数的伪代码

merge(A[p...r], A[p...q], A[q+1...r]) {var i := p，j := q+1，k := 0 // 初始化变量i, j, kvar tmp := new array[0...r-p] // 申请一个大小跟A[p...r]一样的临时数组while i<=q AND j<=r do {if A[i] <= A[j] {tmp[k++] = A[i++] // i++等于i:=i+1} else {tmp[k++] = A[j++]}}// 判断哪个子数组中有剩余的数据var start := i，end := qif j<=r then start := j, end:=r// 将剩余的数据拷贝到临时数组tmpwhile start <= end do {tmp[k++] = A[start++]}// 将tmp中的数组拷贝回A[p...r]for i:=0 to r-p do {A[p+i] = tmp[i]}
}

归并排序性能分析

稳定排序、非原地排序、时间复杂度为 O(nlogn)，归并排序的执行效率与要排序的原始数组的有序程度无关，所以其时间复杂度是非常稳定的，不管是最好情况、最坏情况，还是平均情况，时间复杂度都是 O(nlogn)。空间复杂度为O(n)。

快速排序

快排的思想是这样的：如果要排序数组中下标从 p 到 r 之间的一组数据，我们选择 p 到 r 之间的任意一个数据作为 pivot（分区点）。我们遍历 p 到 r 之间的数据，将小于 pivot 的放到左边，将大于 pivot 的放到右边，将 pivot 放到中间。经过这一步骤之后，数组 p 到 r 之间的数据就被分成了三个部分，前面 p 到 q-1 之间都是小于 pivot 的，中间是 pivot，后面的 q+1 到 r 之间是大于 pivot 的。根据分治、递归的处理思想，我们可以用递归排序下标从 p 到 q-1 之间的数据和下标从 q+1 到 r 之间的数据，直到区间缩小为 1，就说明所有的数据都有序了。

快排的递推公式

递推公式：
quick_sort(p…r) = quick_sort(p…q-1) + quick_sort(q+1… r)终止条件：
p >= r

快排的伪代码

// 快速排序，A是数组，n表示数组的大小
quick_sort(A, n) {quick_sort_c(A, 0, n-1)
}
// 快速排序递归函数，p,r为下标
quick_sort_c(A, p, r) {if p >= r then returnq = partition(A, p, r) // 获取分区点quick_sort_c(A, p, q-1)quick_sort_c(A, q+1, r)
}

归并排序中有一个 merge() 合并函数，我们这里有一个 partition() 分区函数。partition() 分区函数实际上我们前面已经讲过了，就是随机选择一个元素作为 pivot（一般情况下，可以选择 p 到 r 区间的最后一个元素），然后对 A[p...r]分区，函数返回 pivot 的下标。

如果不考虑空间消耗的，我们申请2个临时数组X,Y，遍历A[p...r]，将小于pivot的元素复制到X,大于pivot的元素复制到Y，最后再将数组X和Y的数据顺序拷贝到A[p...r]即可。示意图：

如果我们希望快排是原地排序算法，那它的空间复杂度得是 O(1)，那 partition() 分区函数就不能占用太多额外的内存空间，我们就需要在 A[p...r]的原地完成分区操作：

/**游标i对应的是什么数字并不关心，它只是一个分界线，游标i前面的区间都是小于pivot的，后面遍历到某个数时，如果小于pivot，那么就跟当前的游标i进行数字交换，然后游标i++ 游标j是遍历游标，一直往前走 游标i是分界游标，只有出现交换操作才会往前走
**/
partition(A, p, r) {pivot := A[r]i := pfor j := p to r-1 do {if A[j] < pivot {swap A[i] with A[j]i := i+1}}swap A[i] with A[r]return i

快排性能分析

通过游标 i 把 A[p...r-1]分成两部分。A[p...i-1]的元素都是小于 pivot 的，我们暂且叫它“已处理区间”，A[i...r-1]是“未处理区间”。我们每次都从未处理的区间 A[i...r-1]中取一个元素 A[j]，与 pivot 对比，如果小于 pivot，则将其加入到已处理区间的尾部，也就是 A[i]的位置。在数组某个位置插入元素，需要搬移数据，非常耗时。当时我们也讲了一种处理技巧，就是交换，在 O(1) 的时间复杂度内完成插入操作。借助这个思想，只需要将 A[i]与 A[j]交换，就可以在 O(1) 时间复杂度内将 A[j]放到下标为 i 的位置。因此快排不是稳定排序算法

快排和归并排序区别：归并排序是自顶向下，先处理子问题，然后再合并；快排是自底向上，先分区，然后再处理子问题。

归并排序虽然是稳定排序，但是是非原地排序；而快速可以实现原地排序。归并排序的时间复杂度跟原数据的是否有序无关，始终是O(nlogn)；快速排序的时间复杂度在极端情况下：如果数组中的数据原来已经是有序的了，比如 1，3，5，6，8。如果每次选择最后一个元素作为 pivot，那每次分区得到的两个区间都是不均等的。需要进行大约 n 次分区操作，才能完成快排的整个过程。每次分区我们平均要扫描大约 n/2 个元素，这种情况下，快排的时间复杂度就从 O(nlogn) 退化成了 O(n2)。但是也有很多方法将这个概率降到很低。所以实际中，快排应用最多而归并排序很少使用。

标题解答

快排核心思想就是分治和分区，我们可以利用分区的思想，来解答开篇的问题：O(n) 时间复杂度内求无序数组中的第 K 大元素。比如4， 2， 5， 12， 3 这样一组数据，第 3 大元素就是 4。

我们选择数组区间 A[0...n-1]的最后一个元素 A[n-1]作为 pivot，对数组 A[0...n-1]原地分区，这样数组就分成了三部分，A[0...p-1]、A[p]、A[p+1...n-1]。如果 p+1=K，那 A[p]就是要求解的元素；如果 K>p+1, 说明第 K 大元素出现在 A[p+1...n-1]区间，我们再按照上面的思路递归地在 A[p+1...n-1]这个区间内查找。同理，如果 K<p+1，那我们就在 A[0...p-1]区间查找。