快速排序分区以及优化方法
Posted 互联网之瞳
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了快速排序分区以及优化方法相关的知识，希望对你有一定的参考价值。
一、快速排序扫描分区法
通过单向扫描，双向扫描，以及三指针分区法分别实现快速排序算法。着重理解分区的思想。
单向扫描分区法
思路：用两个指针将数组划分为三个区间，扫描指针（scan_pos）左边是确认小于等于主元的，扫描指针到某个指针（next_bigger_pos）中间为未知的，因此我们将第二个指针(next_bigger_pos）称为未知区间指针，末指针的右边区间为确认大于主元的元素。主元就是具体的划分数组的元素，主元的选择有讲究，这里选择数组的首元素
代码：
import java.util.Arrays;
public class QuickSort {
public static void main(String[] args) {
int arr[] = new int[10];
for(int i=0;i<10;i++){
arr[i] = (int) ((Math.random()+1)*10);
}
System.out.println("排序前："+Arrays.toString(arr));
quickSort(arr, 0, arr.length-1);
System.out.println("排序后："+Arrays.toString(arr));
}
public static void quickSort(int[]A,int p,int r){
if (p<r) {
int q = partition(A,p,r); // 得到分区返回的一个下标 以此划分数组
quickSort(A, p, q-1);
quickSort(A, q+1, r);
}
}
private static int partition(int[] A, int p, int r) {
int pivot = A[p]; // 主元
int sp = p + 1; // 扫描指针
int bigger = r; // 右侧指针
while(sp<=bigger){
if (A[sp]<=pivot) { // 扫描元素左移，左指针向右移
sp++;
}else {
swap(A,sp,bigger); // 扫描元素大于主元，二指针的元素交换，右指针左移
bigger--;
}
}
swap(A,p,bigger);
return bigger;
}
private static void swap(int[] A, int p, int bigger) {
int temp = A[p];
A[p] = A[bigger];
A[bigger] = temp;
}
}结果：
双向扫描分区法
思路：头尾指针往中间扫描，从左找到大于主元的元素，从右找到小于等于主元的元素二者交换，继续扫描，直到左侧无大元素，右侧无小元素。
代码：
import java.util.Arrays;
public class QuickSort2 {
public static void main(String[] args) {
int arr[] = new int[10];
for(int i=0;i<10;i++){
arr[i] = (int) ((Math.random()+1)*10);
}
System.out.println(Arrays.toString(arr));
quickSort(arr, 0, arr.length-1);
System.out.println(Arrays.toString(arr));
}
public static void quickSort(int[]A,int p,int r){
if (p<r) {
int q = partition2(A,p,r); // 得到分区返回的一个下标 以此划分数组
quickSort(A, p, q-1);
quickSort(A, q+1, r);
}
}
//双向扫描分区法
public static int partition2(int[] arr, int p, int r) {
int left = p + 1; //左侧扫描指针
int right = r; //右侧指针
int pivot = arr[p];
while(left <= right) {
// left不停往右走，直到遇到大于主元的元素
// 循环退出时，left一定是指向第一个大于主元的位置
while(left <= right && arr[left] <= pivot) {
left++;
}
// right不停往左走，直到遇到小于主元的元素
// 循环退出时，right一定是指向从右到左第一个小于于主元的位置
while(left <= right && arr[right] > pivot) {
right--;
}
if(left < right)
swap(arr, left, right);
}
// 循环退出时，两者交错，且right指向的最后一个小于等于主元的位置，也就是主元应该待的位置
swap(arr, p, right);
return right;
}
private static void swap(int[] A, int p, int bigger) {
int temp = A[p];
A[p] = A[bigger];
A[bigger] = temp;
}
}结果：
三指针分区法
思路：当待排序数组中，如果有大量相同的元素，则可以三指针分区法，每次将与主元相等的元素找到，排好序，并记录这组与主元相等元素序列的开始下标和结束下标。在进行下次递归排序时，排除这部分相同的元素。从而减少递归次数。
代码：
import java.util.Arrays;
public class QuickSort3 {
public static void main(String[] args) {
int arr[] = new int[10];
for(int i=0;i<10;i++){
arr[i] = (int) ((Math.random()+1)*10);
}
System.out.println("排序前："+Arrays.toString(arr));
quickSort(arr, 0, arr.length-1);
System.out.println("排序后："+Arrays.toString(arr));
}
public static void quickSort(int[]A,int p,int r){
if (p<r) {
int q[] = partition3(A,p,r); // 得到分区返回的一个下标 以此划分数组
quickSort(A, p, q[0]-1);
quickSort(A, q[1]+1, r);
}
}
private static int[] partition3(int[] arr, int p, int r) {
int s = p + 1; //左扫描指针
int e = s; //记录与主元相等元素序列的开始下标
int bigger = r; //右侧扫描指针
int pivot = arr[p]; //主元
while (s <= bigger) {
while(s <= bigger && arr[s] <= pivot) {
//当从一开始没有找到与主语相等的元素，且都小于主元时，指针右移
if(s <= bigger && s == e && arr[s] < pivot) {
s++;
e++;
}
//如过s!=e时，说明已经找到与主元相等的元素，且e记录的为与主元相等元素的开始下标
//如果下一个元素小于主元，则将小于主元的元素和与主元相等序列的第一个元素交换位置
if(s <= bigger && s != e && arr[s] < pivot) {
swap(arr, s, e);
e++;
s++;
}
//如果遇到等于主元的元素，左扫描指针++， 记录与主元相等序列的开始下标e不变
if(s <= bigger && arr[s] == pivot) {
s++;
}
}
//右侧扫描指针
while(s <= bigger && arr[bigger] > pivot) {
bigger--;
}
//将左侧指针指向大的元素与右侧小于主元的元素交换
if(s <= bigger && arr[s] > arr[bigger]) {
swap(arr, s, bigger);
}
}
//最后，数组下标为p的开始元素，和与主元相等序列的前一个元素交换，e--
swap(arr, p, --e);
//返回与主元相等序列的开始下标和结束下标
int[] q = {e, bigger};
return q;
}
private static void swap(int[] A, int p, int bigger) {
int temp = A[p];
A[p] = A[bigger];
A[bigger] = temp;
}
}结果：
二、快速排序在工程实践中优化方法
1、三点中值法：Arrays.sort()方法就是采用的三点中值法。在上面的例子中，每次取的主元都是待排序子序列的首元素，很大可能不是属于中间的元素，从而容易加大递归的层数。三点中值法就是对待排序数组的开始，中间，最后三个元素的大小进行比较，然后取中间值，这样很大概率能使主元成为中间的元素，从而减少递归层数。
//三点中值法
public static int partition(int[] arr, int p, int r) {
//优化，在p, r, mid之间，选一个中间值作为主元
int midIndex = p + ((r - p) >> 1);//中间下标
int midValueIndex = -1;//中值的下标
if(arr[p] <= arr[midIndex] && arr[p] >= arr[r]) {
midValueIndex = p;
}else if(arr[r] <= arr[midIndex] && arr[r] >= arr[p]) {
midValueIndex = r;
}else {
midValueIndex = midIndex;
}
swap(arr, p, midValueIndex);
int pivot = arr[p];
int left = p + 1; //左侧指针
int right = r; //右侧指针
while(left <= right) {
while(left <= right && arr[left] <= pivot) {
left++;
}
while(left <= right && arr[right] > pivot) {
right--;
}
if(left < right) {
swap(arr, left, right);
}
}
swap(arr, p, right);
return right;
}2、绝对中值法：三点中值法也有很大的随机性，如果想要得到绝对的中值，可以通过绝对中值法来获取主元，通过将待排序数组以5个元素分为一组，取中间值，取到整个数组的各组中间值，再将这些数排序，再取中间值作为主元。因为寻找绝对中值，也会花费时间，所以使用三点中值法居多。
/**
* 获取绝对的中值数，O(N)的样子
*/
public static int getMedian(int[] arr, int p, int r) {
if (arr.length == 1)
return arr[p];
int size = r - p + 1;// 数组长度
//每五个元素一组
int groupSize = (size % 5 == 0) ? (size / 5) : (size / 5 + 1);
//存储各小组的中值
int medians[] = new int[groupSize];
int indexOfMedians = 0;
//对每一组进行插入排序
for (int j = 0; j < groupSize; j++) {
//单独处理最后一组，因为最后一组可能不满5个元素
if (j == groupSize - 1) {
InsertionSort.sort(arr, p + j * 5, r); // 排序最后一组
medians[indexOfMedians++] = arr[(p + j * 5 + r) / 2]; // 最后一组的中间那个
} else {
InsertionSort.sort(arr, p + j * 5, p + j * 5 + 4); // 排序非最后一组的某个组
medians[indexOfMedians++] = arr[p + j * 5 + 2]; // 当前组（排序后）的中间那个
}
}
return getMedian(medians, 0, medians.length - 1);
}3、待排序列表较短时，用插入排序：当排序列表小于8个时，通过计算发现插入排序比快速排序的性能要好。
以上是关于快速排序分区以及优化方法的主要内容，如果未能解决你的问题，请参考以下文章