目录
概念
快速排序算法是由C.A.R Hoare在1962年提出来的。快速排序是冒泡排序的改进算法。它也是通过不断比较和移动交换来实现排序的,只不过它的实现增大了记录的比较和移动的距离,将关键字较大的元素从前面直接放到后面,关键字较小的元素直接从后面放到前面,从而减小了比较次数和交换次数。
基本思想
通过一趟排序,将要排序的数据分割成为独立的两个部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按照此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
快速排序详细步骤图
代码实现
普通快速排序
NormalQuickSort.java
package com.liubin.algorithm.sort.quick;
import java.util.Arrays;
import java.util.Random;
/**
* 〈功能详细描述〉
*
* @author 刘斌
* @date 2020/3/8
* @see [相关类/方法](可选)
* @since [产品/模块版本] (可选)
*/
public class NormalQuickSort {
public static void main(String[] args) {
int[] data1 = {3, 8, 5, 7, 10, 4, 15, 12, 20, 40, 24, 28};
System.out.println("data1排序前==>" + Arrays.toString(data1));
quickSort(data1);
System.out.println("data1排序后==>" + Arrays.toString(data1));
int[] data2 = generateRandomArray(30, 10, 1000);
System.out.println("\ndata2排序前==>" + Arrays.toString(data2));
quickSort(data2);
System.out.println("data2排序后==>" + Arrays.toString(data2));
int[] data3 = generateRandomArray(10000, 10, 20000);// 随机生成一万个整数,在10-20000区间
System.out.print("\n在10-20000区间,随机生成一万个整数,");
quickSort(data3);
}
public static void quickSort(int[] array) {// 快排
long start = System.nanoTime();
int n = array.length;
if (n <= 1) {// 判断待排序数组是否为空数组或只含有一个元素,若是则直接返回
return;
}
quickSortInternal(array, 0, n - 1);
long end = System.nanoTime();
System.out.println("普通(基础)快排耗时:" + (end - start) + "纳秒");// 测试程序耗时
}
// 快排递归
private static void quickSortInternal(int[] array, int low, int high) {
if (low >= high) {// 递归推出条件
return;
}
int q = partition(array, low, high);// 确定分区点最终位置
quickSortInternal(array, low, q - 1);// 左边区间(小于区分点元素)递归排序
quickSortInternal(array, q + 1, high);// 右边区间(大于等于区分点元素)递归排序
}
/**
* 对数组array[l...r]部分进行partition操作 返回p,使得array[l+1...p-1]<array[p],array[p+1...r]>=array[p]</array[p],array[p+1...r]>
*
* @param array 待排序数组
* @param l 数组开始点
* @param r 数组结束点
* @return 分区点下标
*/
private static int partition(int[] array, int l, int r) {
// 默认比较元素为待排序数组的第一个元素
int v = array[l];
// [l+1...j]为<v的元素区间(刚开始为空区间,随着<v元素的加入区间加长)
int j = l;
// [j+1...i-1]为>=v的元素区间(刚开始为空区间,随着>=v元素的加入区间加长)
int i = l + 1;// i下标作用在于遍历除比较元素外的其他元素,即从第二个元素开始到结尾
for (; i <= r; i++) {// 遍历数组
if (array[i] < v) {// 当大于等于v时保持不动即可,<v时放置j下标区间
swap(array, i, j + 1);
j++;
}
}
// 此时<v元素在前面,>=v元素在后面区间,将<v元素区间的最后一个元素与比较元素交换即可以达到最终效果(区分点元素到达最终位置,<v的元素在区分点左边区间,>=v的元素在区分点右边区间)
swap(array, l, j);
return j;// 返回区分点下标
}
private static void swap(int[] array, int i, int j) {// 交换
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
// 随机生成数字
public static int[] generateRandomArray(int n, int rangeL, int rangeR) {
if (rangeL > rangeR) {
throw new IndexOutOfBoundsException("越界异常");
}
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = new Integer(new Random().nextInt(rangeR - rangeL + 1) + rangeL);
}
return arr;
}
}
普通快速排序-控制台输出
普通快速排序优化版本
上述普通快排存在的问题
NormalQuickSortOptimize.java
package com.liubin.algorithm.sort.quick;
import java.util.Arrays;
import java.util.Random;
/**
* 〈功能详细描述〉
*
* @author 刘斌
* @date 2020/3/8
* @see [相关类/方法](可选)
* @since [产品/模块版本] (可选)
*/
public class NormalQuickSortOptimize {
public static void main(String[] args) {
//首先将10000个整数先排序好,模拟左右分区极度不均衡状态,
// 比如极端情况下,数组已经升序有序时,每次选择第一个元素为区分点导致左右两个区间极度不平衡,全部元素位于右边区间,此时就需要大约n次分区操作,每次分区我们大约要扫描n/2个元素
int[] data1 = generateRandomArray(10000, 10, 20000);// 随机生成一万个整数,在10-20000区间
System.out.print("\n在10-20000区间,随机生成一万个整数,");
quickSort(data1);
int[] data2 = data1;
System.out.println("data2排序前==>" + Arrays.toString(data2));
quickSort(data2);
System.out.println("data2排序后==>" + Arrays.toString(data2));
int[] data3 = data1;
System.out.println("\ndata3排序前==>" + Arrays.toString(data3));
quickSortOptimize(data3);
System.out.println("data3排序后==>" + Arrays.toString(data3));
}
public static void quickSort(int[] array) {// 快排
long start = System.currentTimeMillis();
int n = array.length;
if (n <= 1) {// 判断待排序数组是否为空数组或只含有一个元素,若是则直接返回
return;
}
quickSortInternal(array, 0, n - 1);
long end = System.currentTimeMillis();
System.out.println("普通(基础)快排耗时:" + (end - start) + "毫秒");// 测试程序耗时
}
// 快排递归
private static void quickSortInternal(int[] array, int low, int high) {
if (low >= high) {// 递归推出条件
return;
}
int q = partition(array, low, high);// 确定分区点最终位置
quickSortInternal(array, low, q - 1);// 左边区间(小于区分点元素)递归排序
quickSortInternal(array, q + 1, high);// 右边区间(大于等于区分点元素)递归排序
}
/**
* 对数组array[l...r]部分进行partition操作 返回p,使得array[l+1...p-1]<array[p],array[p+1...r]>=array[p]</array[p],array[p+1...r]>
*
* @param array 待排序数组
* @param l 数组开始点
* @param r 数组结束点
* @return 分区点下标
*/
private static int partition(int[] array, int l, int r) {
// 默认比较元素为待排序数组的第一个元素
int v = array[l];
// [l+1...j]为<v的元素区间(刚开始为空区间,随着<v元素的加入区间加长)
int j = l;
// [j+1...i-1]为>=v的元素区间(刚开始为空区间,随着>=v元素的加入区间加长)
int i = l + 1;// i下标作用在于遍历除比较元素外的其他元素,即从第二个元素开始到结尾
for (; i <= r; i++) {// 遍历数组
if (array[i] < v) {// 当大于等于v时保持不动即可,<v时放置j下标区间
swap(array, i, j + 1);
j++;
}
}
// 此时<v元素在前面,>=v元素在后面区间,将<v元素区间的最后一个元素与比较元素交换即可以达到最终效果(区分点元素到达最终位置,<v的元素在区分点左边区间,>=v的元素在区分点右边区间)
swap(array, l, j);
return j;// 返回区分点下标
}
private static void swap(int[] array, int i, int j) {// 交换
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
// 随机生成数字
public static int[] generateRandomArray(int n, int rangeL, int rangeR) {
if (rangeL > rangeR) {
throw new IndexOutOfBoundsException("越界异常");
}
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = new Integer(new Random().nextInt(rangeR - rangeL + 1) + rangeL);
}
return arr;
}
//普通快排优化版本
public static void quickSortOptimize(int[] array) {// 快排
long start = System.currentTimeMillis();
int n = array.length;
if (n <= 1) {// 判断待排序数组是否为空数组或只含有一个元素,若是则直接返回
return;
}
quickSortInternalOptimize(array, 0, n - 1);
long end = System.currentTimeMillis();
System.out.println("普通快速排序优化版耗时:" + (end - start) + "毫秒");// 测试程序耗时
}
// 快排递归优化版本
private static void quickSortInternalOptimize(int[] array, int low, int high) {
if (low >= high) {// 递归推出条件
return;
}
int q = partition(array, low, high);// 确定分区点最终位置
partitionOptimize(array, low, q - 1);// 左边区间(小于区分点元素)递归排序
partitionOptimize(array, q + 1, high);// 右边区间(大于等于区分点元素)递归排序
}
private static int partitionOptimize(int[] array, int l, int r) {// 每次快排随机生成分区点
// Math.random()为产生一个[0,1)的随机数(double)
int randomIndex = (int) (Math.random() * (r - l + 1) + l);// 随机数*数组长度+左下标然后强转确保区分点下标在数组合理下标范围内
swap(array, randomIndex, l);// 将第一个元素与随机区分点元素交换
int v = array[l];// 每次获得随机区分点元素
int j = l;
int i = l + 1;
for (; i <= r; i++) {
if (array[i] < v) {
swap(array, i, j + 1);
j++;
}
}
swap(array, j, l);
return j;
}
}