快速排序
速排序由于排序效率在同为O(N*logN)的几种排序方法中效率较高，因此经常被采用，再加上快速排序思想----分治法也确实实用，因此很多软件公司的笔试面试，包括像腾讯，微软等知名IT公司都喜欢考这个，还有大大小的程序方面的考试如软考，考研中也常常出现快速排序的身影。
总的说来，要直接默写出快速排序还是有一定难度的，因为本人就自己的理解对快速排序作了下白话解释，希望对大家理解有帮助，达到快速排序，快速搞定。
快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。
该方法的基本思想是：
1．先从数列中取出一个数作为基准数。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对左右区间重复第二步，直到各区间只有一个数。
虽然快速排序称为分治法，但分治法这三个字显然无法很好的概括快速排序的全部步骤。因此我的对快速排序作了进一步的说明：挖坑填数+分治法：
import java.util.Arrays; /** * 第1次排序:[9, 6, 12, 34, 45, 79, 65] * 第2次排序:[6, 9, 12, 34, 45, 79, 65] * 第3次排序:[6, 9, 12, 34, 45, 79, 65] * 第4次排序:[6, 9, 12, 34, 45, 65, 79] */ public class QuickSort { public static int count = 0; public static void main(String[] args) { int array[] = {34, 65, 12, 45, 6, 79, 9}; quickSort(array); } public static void quickSort(int[] array) { if (array != null) { quickSort(array, 0, array.length - 1); } } private static void quickSort(int[] array, int beg, int end) { if (beg >= end || array == null) return; int p = partition(array, beg, end); // System.out.println("第一次排序"); System.out.print("第" + (++count) + "次排序:"); System.out.print(Arrays.toString(array)); System.out.println(); quickSort(array, beg, p - 1); quickSort(array, p + 1, end); } private static int partition(int[] array, int beg, int end) { int pivot = array[beg]; while (beg < end) { while (beg < end && array[end] >= pivot) end--; if (beg < end) array[beg++] = array[end]; while (beg < end && array[beg] <= pivot) beg++; if (beg < end) array[end--] = array[beg]; } array[beg] = pivot; return beg; } } // 快排空间复杂度O（log2（n）） 归并O(n) // // 心情不稳当，快些选一对好友来聊天-----------快速，希尔，简单选择，堆排序---------------不稳当 // // 快些以 nlog2(n)归队------------------------快速，希尔，归并，堆排序----------------------时间负载度 nlog2(n) // // // // 直接插容易插成O（n），起泡起的好编程O(n)------------------容易插，起的好，都是初始化序列已经有序
下面以中间为基排序
这个时候要注意，比较条件是大于或者小于，不能有等于，不然程序会出错
import java.util.Arrays;
import java.util.Comparator;
/**
* 快速排序。
* <p>
* 第1次排序:[34, 9, 12, 6, 45, 79, 65]
* 第2次排序:[6, 9, 12, 34, 45, 79, 65]
* 第3次排序:[6, 9, 12, 34, 45, 79, 65]
* 第4次排序:[6, 9, 12, 34, 45, 65, 79]
* 第5次排序:[6, 9, 12, 34, 45, 65, 79]
* 最终结果
* [6, 9, 12, 34, 45, 65, 79]
*/
/**
* 第1次排序:[34, 9, 12, 6, 45, 79, 65]
* 第2次排序:[6, 9, 12, 34, 45, 79, 65]
* 第3次排序:[6, 9, 12, 34, 45, 79, 65]
* 第4次排序:[6, 9, 12, 34, 45, 65, 79]
* 第5次排序:[6, 9, 12, 34, 45, 65, 79]
* 最终结果
* [6, 9, 12, 34, 45, 65, 79]
*/
/**
* 分治和递归，以中间为准基数，分割数组为两部分，
* 如果左边的index0指向数据小于准基数，则满足条件（左边的小于准基数），
* 下标增加一（index0++），用下一个数据和准基数对比，如果满足，再看一下个数据。
* 如果右边的数据大于准基数，则满足条件（右边的数据大于准基数），
* 下边减一（index1--），用上一个数据和准基数进行对比。。。
*/
public class QuickSort2 {
public static int count = 0;
public static void QuickSort2(int[] inputs, Comparator<Integer> cp) {
sort(inputs, 0, inputs.length - 1, cp);
}
/**
* 快速排序算法，结果是从小到大。
*
* @param inputs 待排序对象数组。
* @param low 首
* @param high 尾
*/
private static void sort(int[] inputs, int low, int high,
Comparator<Integer> cp) {
int index0 = low;
int index1 = high;
int mid;
if (high > low) {
mid = inputs[(low + high) / 2];
while (index0 <= index1) {
while ((index0 < high) && (cp.compare(inputs[index0], mid) < 0)) {
++index0;
}
while ((index1 > low) && (cp.compare(inputs[index1], mid) > 0)) {
--index1;
}
if (index0 <= index1) {
swap(inputs, index0, index1);
++index0;
--index1;
}
}
System.out.print("第" + (++count) + "次排序:");
System.out.print(Arrays.toString(inputs));
System.out.println();
if (low < index1) {
sort(inputs, low, index1, cp);
}
if (index0 < high) {
sort(inputs, index0, high, cp);
}
}
}
/**
* 交换。
*
* @param objs
* @param i
* @param j
*/
private static void swap(int[] objs, int i, int j) {
int T;
T = objs[i];
objs[i] = objs[j];
objs[j] = T;
}
public static void main(String[] args) {
int array[] = {34, 65, 12, 45, 6, 79, 9};
Comparator<Integer> integerComparator = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
};
QuickSort2(array, integerComparator);
System.out.println("最终结果");
System.out.println(Arrays.toString(array));
}
}
import java.util.Arrays; /** * 快速排序。 * 第1次排序:[34, 9, 12, 6, 45, 79, 65] * 第2次排序:[6, 9, 12, 34, 45, 79, 65] * 第3次排序:[6, 9, 12, 34, 45, 79, 65] * 第4次排序:[6, 9, 12, 34, 45, 65, 79] * 第5次排序:[6, 9, 12, 34, 45, 65, 79] * [6, 9, 12, 34, 45, 65, 79] */ public class QuickSort3 { public static int count = 0; public static void QuickSort3(int[] inputs) { sort(inputs, 0, inputs.length - 1); } /** * 快速排序算法，结果是从小到大。 * * @param inputs 待排序对象数组。 * @param low 首 * @param high 尾 */ private static void sort(int[] inputs, int low, int high) { int index0 = low; int index1 = high; int mid; if(count==3){ System.out.println(111); } if (high > low) { mid = inputs[(low + high) / 2]; while (index0 <= index1) { while ((index0 < high) && ((inputs[index0] - mid) < 0)) { ++index0; } while ((index1 > low) && ((inputs[index1] - mid) > 0)) { --index1; } if (index0 <= index1) { swap(inputs, index0, index1); ++index0; --index1; } } System.out.print("第" + (++count) + "次排序:"); System.out.print(Arrays.toString(inputs)); System.out.println(); if (low < index1) { sort(inputs, low, index1); } if (index0 < high) { sort(inputs, index0, high); } } } /** * 交换。 * * @param objs * @param i * @param j */ private static void swap(int[] objs, int i, int j) { int T; T = objs[i]; objs[i] = objs[j]; objs[j] = T; } public static void main(String[] args) { int array[] = {34, 65, 12, 45, 6, 79, 9}; QuickSort3(array); System.out.println(Arrays.toString(array)); } }
这个问题其实也没有多么复杂，但是网上这部分内容不多，故总结一下最优与最差比较次数。
n个元素线性表快速排序，最好情况下比较次数是多少？
参照严书的方法，以第一位作为标杆。
①考虑第一趟排序，无论怎样也要有n-1次比较次数；
②如果此时能把数据分成两部分，前一部分与后一部分元素个数相近，那样就是最优的。
例如，4 1 2 3 5 6 7，经过一趟排序，变成 1 2 3 4 5 6 7 。也就是说，以4为标杆，一趟后分成了两部分，这两部分个数相同或相差 1，那么快排会很优。
于是，可以想到，最优时，n个数，第一趟分成前⌊(n-1)/2⌋，后⌈(n-1)/2⌉两组，每组也是按照最优的分，设最优是an，于是有：
an = a⌊(n-1/2)⌋+a⌈(n-1/2)⌉ + n - 1
比如，n=7时，最优情况就是 a7=a3+a3+6 ，a3=a1+a1+2 ，而显然a1=0。
于是a3=2，a7=10。
举 例 4 1 3 2 6 5 7 。第一次4为标杆，一趟后为 2 1 34 6 5 7
第二趟两边分别以2,6为标杆，这样最好，因为是均分了。
问题，n=8时，最好排序次数？
a8=7+a4+a3，a3算的2，a4=3+a1+a2，显然a2=1，于是a4=4，故a8=13
因此，n=8时，最好情况下比较次数是13。
举例，4 1 3 2 6 5 7 8 可以数一下
对于别的情况，参照这个思路即可轻松求比较次数以及举例。
n个元素线性表快速排序，最坏情况下比较次数是多少？
这个就容易多了，因为顺序或者逆序时最坏的。
故比较次数，1+2+3……+ n-1 = n(n-1)/2
