排序算法-快速排序

我在上一篇博文讲了冒泡排序，今天上午呢我们继续第二个排序算法，那就是快速排序。话不多说，直接进入正题。

原创不易，如果转载请注明链接：
https://blog.csdn.net/qq_38305457/article/details/95730815

我不能保证写的每个地方都是对的，但是至少能保证不复制，不黏贴，保证每一句话，每一行代码都经过了认真的推敲，仔细的斟酌。每一篇文章的背后，希望都能看到自己对于技术，对于生活的态度。
我相信乔布斯说的，只有那些疯狂到认为自己可以改变世界的人才能真正的改变世界。
面对压力，我可以挑灯夜战，不眠不休；面对困难，我愿意迎难而上，永不退缩。 其实我想说的是：我只是一个程序员，这就是我现在纯粹人生的全部。

1、基本思想

快速排序（Quicksort）是对冒泡排序的一种改进，借用了分治的思想，由C. A. R. Hoare在1962年提出。
快速排序的基本思想：挖坑填数+分治法。

首先选一个轴值(pivot，也有叫基准的)，通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

2、算法描述

快速排序使用分治策略来把一个序列（list）分为两个子序列（sub-lists）。步骤为：

①. 从数列中挑出一个元素，称为”基准”（pivot）。
②. 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
③. 递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归到最底部时，数列的大小是零或一，也就是已经排序好了。这个算法一定会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

3、代码实现

用伪代码描述如下：

①. i = L; j = R; 将基准数挖出形成第一个坑a[i]。
②．j–，由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。
③．i++，由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。
④．再重复执行②，③二步，直到i==j，将基准数填入a[i]中

/**
 * 快速排序（递归）
 *
 * ①. 从数列中挑出一个元素，称为"基准"（pivot）。
 * ②. 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
 * ③. 递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。
 * @param arr   待排序数组
 * @param low   左边界
 * @param high  右边界
 */
public static void quickSort(int[] arr, int low, int high){
 if(arr.length <= 0) return;
 if(low >= high) return;
 int left = low;
 int right = high;

 int temp = arr[left];   //挖坑1：保存基准的值
 while (left < right){
 while(left < right && arr[right] >= temp){  //坑2：从后向前找到比基准小的元素，插入到基准位置坑1中
 right--;
 }
 arr[left] = arr[right];
 while(left < right && arr[left] <= temp){   //坑3：从前往后找到比基准大的元素，放到刚才挖的坑2中
 left++;
 }
 arr[right] = arr[left];
 }
 arr[left] = temp;   //基准值填补到坑3中，准备分治递归快排
 System.out.println("Sorting: " + Arrays.toString(arr));
 quickSort(arr, low, left-1);
 quickSort(arr, left+1, high);
}

上面是递归版的快速排序：通过把基准temp插入到合适的位置来实现分治，并递归地对分治后的两个划分继续快排。那么非递归版的快排如何实现呢？

因为递归的本质是栈，所以我们非递归实现的过程中，可以借助栈来保存中间变量就可以实现非递归了。在这里中间变量也就是通过Pritation函数划分区间之后分成左右两部分的首尾指针，只需要保存这两部分的首尾指针即可。

/**
 * 快速排序（非递归）
 *
 * ①. 从数列中挑出一个元素，称为"基准"（pivot）。
 * ②. 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
 * ③. 把分区之后两个区间的边界（low和high）压入栈保存，并循环①、②步骤
 * @param arr   待排序数组
 */
public static void quickSortByStack(int[] arr){
 if(arr.length <= 0) return;
 Stack<Integer> stack = new Stack<Integer>();

 //初始状态的左右指针入栈
 stack.push(0);
 stack.push(arr.length - 1);
 while(!stack.isEmpty()){
 int high = stack.pop();     //出栈进行划分
 int low = stack.pop();

 int pivotIdx = partition(arr, low, high);

 //保存中间变量
 if(pivotIdx > low) {
 stack.push(low);
 stack.push(pivotIdx - 1);
 }
 if(pivotIdx < high && pivotIdx >= 0){
 stack.push(pivotIdx + 1);
 stack.push(high);
 }
 }
}

private static int partition(int[] arr, int low, int high){
 if(arr.length <= 0) return -1;
 if(low >= high) return -1;
 int l = low;
 int r = high;

 int pivot = arr[l];    //挖坑1：保存基准的值
 while(l < r){
 while(l < r && arr[r] >= pivot){  //坑2：从后向前找到比基准小的元素，插入到基准位置坑1中
 r--;
 }
 arr[l] = arr[r];
 while(l < r && arr[l] <= pivot){   //坑3：从前往后找到比基准大的元素，放到刚才挖的坑2中
 l++;
 }
 arr[r] = arr[l];
 }
 arr[l] = pivot;   //基准值填补到坑3中，准备分治递归快排
 return l;
}

快速排序是通常被认为在同数量级（O(nlog2n)）的排序方法中平均性能最好的。但若初始序列按关键码有序或基本有序时，快排序反而蜕化为冒泡排序。为改进之，通常以“三者取中法”来选取基准记录，即将排序区间的两个端点与中点三个记录关键码居中的调整为支点记录。快速排序是一个不稳定的排序方法。

以下是快速排序算法复杂度:
快速排序排序效率非常高。 虽然它运行最糟糕时将达到O(n²)的时间复杂度, 但通常平均来看, 它的时间复杂为O(nlogn), 比同样为O(nlogn)时间复杂度的归并排序还要快. 快速排序似乎更偏爱乱序的数列, 越是乱序的数列, 它相比其他排序而言, 相对效率更高.

Tips: 同选择排序相似, 快速排序每次交换的元素都有可能不是相邻的, 因此它有可能打破原来值为相同的元素之间的顺序. 因此, 快速排序并不稳定.