快速排序最全详解（java）

快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。

 

该方法的基本思想是：

1．先从数列中取出一个数作为基准数。

2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

3．再对左右区间重复第二步，直到各区间只有一个数。

思路1 对挖坑填数进行总结 （LeetCode可以通过）

对挖坑填数进行总结

1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。

2．j--由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。

3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。

4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中。

int AdjustArray(int s[], int l, int r) //返回调整后基准数的位置 { int i = l, j = r; int x = s[l]; //s[l]即s[i]就是第一个坑 while (i < j) { // 从右向左找小于x的数来填s[i] while(i < j && s[j] >= x){ j--; } if(i < j) { s[i] = s[j]; //将s[j]填到s[i]中，s[j]就形成了一个新的坑 i++; } // 从左向右找大于或等于x的数来填s[j] while(i < j && s[i] < x) { i++; } if(i < j) { s[j] = s[i]; //将s[i]填到s[j]中，s[i]就形成了一个新的坑 j--; } } //退出时，i等于j。将x填到这个坑中。 s[i] = x; return i; } void quick_sort1(int s[], int l, int r) { if (l < r) { int i = AdjustArray(s, l, r); //先成挖坑填数法调整s[] quick_sort1(s, l, i - 1); // 递归调用 quick_sort1(s, i + 1, r); } } public static void main(String[] args) { int[] arr = { 49, 38, 65, 97, 23, 22, 76, 1, 5, 8, 2, 0, -1, 22 }; quickSort1(arr, 0, arr.length - 1); System.out.println("排序后:"); for (int i : arr) { System.out.println(i); } }

方法2 LeetCode  显示超时

private static void quickSort(int[] arr, int low, int high) { if (low < high) { // 找寻基准数据的正确索引 int index = getIndex(arr, low, high); // 进行迭代对index之前和之后的数组进行相同的操作使整个数组变成有序 quickSort(arr, 0, index - 1); quickSort(arr, index + 1, high); } } private static int getIndex(int[] arr, int low, int high) { // 基准数据 int tmp = arr[low]; while (low < high) { // 当队尾的元素大于等于基准数据时,向前挪动high指针 while (low < high && arr[high] >= tmp) { high--; } // 如果队尾元素小于tmp了,需要将其赋值给low arr[low] = arr[high]; // 当队首元素小于等于tmp时,向前挪动low指针 while (low < high && arr[low] <= tmp) { low++; } // 当队首元素大于tmp时,需要将其赋值给high arr[high] = arr[low]; } // 跳出循环时low和high相等,此时的low或high就是tmp的正确索引位置 // 由原理部分可以很清楚的知道low位置的值并不是tmp,所以需要将tmp赋值给arr[low] arr[low] = tmp; return low; // 返回tmp的正确位置 } } public static void main(String[] args) { int[] arr = { 49, 38, 65, 97, 23, 22, 76, 1, 5, 8, 2, 0, -1, 22 }; quickSort(arr, 0, arr.length - 1); System.out.println("排序后:"); for (int i : arr) { System.out.println(i); } }

方法3 LeetCode （相当于从中间开始）进行了优化

class Solution { public int[] sortArray(int[] nums) { if(nums == null || nums.length == 0){ return nums; } quickSort(nums, 0, nums.length - 1); return nums; } public void quickSort(int[] nums, int start, int end){ if(start >= end){ return; } int privo = nums[(start + end) / 2]; int left = start, right = end; while(left <= right){ while(left <= right && nums[left] < privo){ left++; } while(left <= right && nums[right] > privo){ right--; } if(left <= right){ int temp = nums[left]; nums[left] = nums[right]; nums[right] = temp; left++; right--; } } quickSort(nums, start, right); quickSort(nums, left, end); } }

方法4 直接交换

/** * @Auther: liuhaidong * Data: 2019/10/12 0012、15:49 * Description: * @version: 1.0 */ public class quickSortTest { public static void main(String[] args){ int[] arr = {6,1,2,7,9,3,4,5,10,8}; quickSort(arr, 0, arr.length-1); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i]+" "); } } public static void quickSort(int[] arr,int low,int high){ int i,j,temp,t; if(low>high){ return; } i=low; j=high; //temp就是基准位 temp = arr[low]; while (i<j) { //先看右边，依次往左递减 while (temp<=arr[j]&&i<j) { j--; } //再看左边，依次往右递增 while (temp>=arr[i]&&i<j) { i++; } //如果满足条件则交换 if (i<j) { t = arr[j]; arr[j] = arr[i]; arr[i] = t; } } //最后将基准为与i和j相等位置的数字交换 arr[low] = arr[i]; arr[i] = temp; //递归调用左半数组 quickSort(arr, low, j-1); //递归调用右半数组 quickSort(arr, j+1, high); } }

5 Java 快速排序 关于起始方向的选择问题 为什么一定要从右边开始

 

这是因为快速排序从右边开始的原因是因为选择的基准值key一般都是最左边的元素。

假设左哨兵为i 右哨兵为j 选择的key为最左边的元素

也就是说

当首先从右边开始先执行时，循环的条件是:

while (i < j && array[j] >= key) j--;

最后i、j 停留的位置的值肯定是要 小于 key 的 此时交换索引 j 和最左边元素key 符合将小于key的值放到key左边这一条件

当首先从左边开始执行时

while (i < j && array[i] <= key) i++;

循环结束后的 i j 碰面的时的值肯定是要 大于 key的 此时再交换key与索引位置 相当于把比key大的值放到了key左边 也就违背了快排的条件

所以如果想先从左往右查找，只需把key设置在右侧即可。

6 时间复杂度

快速排序我们可以近似的想成一个完全二叉树

 

一个数组的容量是N,第一层递归遍历的次数是N,因为数组里每个数字都需要和key比较,那么接下来遍历分出来的两个区间，总的遍历次数还会是近似是N,以此类推,直到分为最后一个,也就是说树的高度是lgn,也就是递归次数,所以时间复杂度是N*lgN.

 

时间复杂度和算法稳定性

最优的情况下空间复杂度为：O(logN)

最差的情况下空间复杂度为：O(N^2)

快速排序的平均时间复杂度是：O(N*logN)

时间复杂度计算

  快速排序涉及到递归调用，所以该算法的时间复杂度还需要从递归算法的复杂度开始说起；

       递归算法的时间复杂度公式：T[n] = aT[n/b] + f(n)  ；对于递归算法的时间复杂度这里就不展开来说了；

最优情况下时间复杂度

        快速排序最优的情况就是每一次取到的元素都刚好平分整个数组(很显然我上面的不是)；

       

               综上所述：快速排序最优的情况下时间复杂度为：O( nlogn )

最差情况下时间复杂度

        最差的情况就是每一次取到的元素就是数组中最小/最大的，这种情况其实就是冒泡排序了(每一次都排好一个元素的顺序)

这种情况时间复杂度就好计算了，就是冒泡排序的时间复杂度：T[n] = n * (n-1) = n^2 + n;

     综上所述：快速排序最差的情况下时间复杂度为：O( n^2 )

7 空间复杂度

        其实这个空间复杂度不太好计算，因为有的人使用的是非就地排序，那样就不好计算了（因为有的人用到了辅助数组，所以这就要计算到你的元素个数了）；我就分析下就地快速排序的空间复杂度吧；

        首先就地快速排序使用的空间是O(1)的，也就是个常数级；而真正消耗空间的就是递归调用了，因为每次递归就要保持一些数据；

     最优的情况下空间复杂度为：O(logn)  ；每一次都平分数组的情况

     最差的情况下空间复杂度为：O( n )      ；退化为冒泡排序的情况

找到更好的基准数

最好情况

在最好的情况下，每次我们进行一次分区，我们会把一个序列刚好分为几近相等的两个子序列，这个情况也我们每次递归调用的是时候也就刚好处理一半大小的子序列。这看起来其实就是一个完全二叉树，树的深度为 O(logn)，所以我们需要做 O(logn) 次嵌套调用。但是在同一层次结构的两个程序调用中，不会处理为原来数列的相同部分。因此，程序调用的每一层次结构总共全部需要 O(n) 的时间。所以这个算法在最好情况下的时间复杂度为 O(nlogn)。

事实上，我们并不需要如此精确的分区：即使我们每个基准值把元素分开为 99% 在一边和 1% 在另一边。调用的深度仍然限制在 100logn，所以全部运行时间依然是 O(nlogn)。

最坏情况

事实上，我们总不能保证上面的理想情况。试想一下，假设每次分区后都出现子序列的长度一个为 1 一个为 n-1，那真是糟糕透顶。这一定会导致我们的表达式变成：

T(n) = O(n) + T(1) + T(n-1) = O(n) + T(n-1)

这和插入排序和选择排序的关系式真是如出一辙，所以我们的最坏情况是 O(n²)。

 

 

上面对时间复杂度进行了简要分析，可见我们的时间复杂度和我们的基准数的选择密不可分。基准数选好了，把序列每次都能分为几近相等的两份，我们的快排就跟着吃香喝辣；但一旦选择的基准数很差，那我们的快排也就跟着穷困潦倒。

所以大家就各显神通，出现了各种选择基准数的方式。

固定基准数

上面的那种算法，就是一种固定基准数的方式。如果输入的序列是随机的，处理时间还相对比较能接受。但如果数组已经有序，用上面的方式显然非常不好，因为每次划分都只能使待排序序列长度减一。这真是糟糕透了，快排沦为冒泡排序，时间复杂度为 O(n²)。因此，使用第一个元素作为基准数是非常糟糕的，我们应该立即放弃这种想法。

随机基准数

这是一种相对安全的策略。由于基准数的位置是随机的，那么产生的分割也不会总是出现劣质的分割。但在数组所有数字完全相等的时候，仍然会是最坏情况。实际上，随机化快速排序得到理论最坏情况的可能性仅为1/(2^n）。所以随机化快速排序可以对于绝大多数输入数据达到 O(nlogn) 的期望时间复杂度。

三数取中

虽然随机基准数方法选取方式减少了出现不好分割的几率，但是最坏情况下还是 O(n²)。为了缓解这个尴尬的气氛，就引入了「三数取中」这样的基准数选取方式。

 

我们不妨来分析一下「三数取中」这个方式。我们最佳的划分是将待排序的序列氛围等长的子序列，最佳的状态我们可以使用序列中间的值，也就是第 n/2 个数。可是，这很难算出来，并且会明显减慢快速排序的速度。这样的中值的估计可以通过随机选取三个元素并用它们的中值作为基准元而得到。事实上，随机性并没有多大的帮助，因此一般的做法是使用左端、右端和中心位置上的三个元素的中值作为基准元。显然使用三数中值分割法消除了预排序输入的不好情形，并且减少快排大约 5% 的比较次数。

我们来看看代码是怎么实现的。

public class Test09 { private static void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } private static void printArr(int[] arr) { for (int anArr : arr) { System.out.print(anArr + " "); } } private static int partition(int[] arr, int left, int right) { // 采用三数中值分割法 int mid = left + (right - left) / 2; // 保证左端较小 if (arr[left] > arr[right]) swap(arr, left, right); // 保证中间较小 if (arr[mid] > arr[right]) swap(arr, mid, right); // 保证中间最小，左右最大 if (arr[mid] > arr[left]) swap(arr, left, mid); int pivot = arr[left]; while (right > left) { // 先判断基准数和后面的数依次比较 while (pivot <= arr[right] && left < right) { --right; } // 当基准数大于了 arr[right]，则填坑 if (left < right) { arr[left] = arr[right]; ++left; } // 现在是 arr[right] 需要填坑了 while (pivot >= arr[left] && left < right) { ++left; } if (left < right) { arr[right] = arr[left]; --right; } } arr[left] = pivot; return left; } private static void quickSort(int[] arr, int left, int right) { if (arr == null || left >= right || arr.length <= 1) return; int mid = partition(arr, left, right); quickSort(arr, left, mid); quickSort(arr, mid + 1, right); } public static void main(String[] args) { int[] arr = {6, 4, 3, 2, 7, 9, 1, 8, 5}; quickSort(arr, 0, arr.length - 1); printArr(arr); } }