目录
概念
快速排序算法是由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;
}
}
1533
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
