快速排序的基本思想
快速排序也是利用分治的思想。
如果需要排序的数据的下标是从s到t，在下标s到t之间的任意一个数据作为分区点p，遍历s到t之间的数据，将小于分区点的数据放到分区点p的左边，将大于分区点的数据放到分区点的右边，分区点放在中间，经过这一操作后。数据被分为3个部分，s到p-1之间为小于分区点的数据，p+1到t之间为大于分区点的数据，p为分区点。根据分治递归的处理思想，可以递归排序s到p-1的区间和p+1到t的区间，直到区间缩小为1，说明排序完成，所有数据都已经为有序。
文字还是没有图直观：分区点的择为最末尾的一个元素
首先还是看看分区的操作，一个直观的对比
快速排序的代码实现
先还是从分区函数的实现开始吧
结合图再来看看分区函数的代码实现
/**
* 分区函数，在快速排序中使用的是原地分区，实现非常的巧妙
*
* <p>函数需要返回分区点
*
* @param data 原始数据
* @param s 开始位置
* @param t 结束位置
* @return 分区点的位置
*/
private int partition(T[] data, int s, int t) {
// 1,指定分区点为当前的最后一个元素
int point = t;
int i = s;
for (int j = s; j <= t - 1; j++) {
// i < j ? -1
// 如果数据小于分区点，执行互换操作
if (((Comparable) data[j]).compareTo(data[point]) < 0) {
// 交换数据
swap(data, i, j);
// i向后移动一位，指向分区点
i += 1;
}
}
// 当结束后，将分区点的位置与i互换，即可完成
swap(data, i, point);
// System.out.println(Arrays.toString(data));
return i;
}
/**
* 进行数据交换操作
*
* @param data 原始数据
* @param src 原始位置
* @param target 目标位置
*/
private void swap(T[] data, int src, int target) {
T dataTmp = data[src];
data[src] = data[target];
data[target] = dataTmp;
}
完整的快速排序的实现:
/**
* 快速排序的代码实现
*
* @author liujun
* @version 0.0.1
* @date 2019/10/28
*/
public class QuickSort<T> implements SortInf<T> {
@Override
public void sort(T[] data) {
if (data == null || data.length <= 1) {
return;
}
if (!(data[0] instanceof Comparable)) {
throw new IllegalArgumentException("data not implement compator interface");
}
// 调用快速排序
this.quickSort(data, 0, data.length - 1);
}
private void quickSort(T[] data, int s, int t) {
// 当前需操作元素仅一个，则退出
if (t - s < 1) {
return;
}
int point = this.partition(data, s, t);
quickSort(data, s, point - 1);
quickSort(data, point + 1, t);
}
/**
* 分区函数，在快速排序中使用的是原地分区，实现非常的巧妙
*
* <p>函数需要返回分区点
*
* @param data 原始数据
* @param s 开始位置
* @param t 结束位置
* @return 分区点的位置
*/
private int partition(T[] data, int s, int t) {
// 1,指定分区点为当前的最后一个元素
int point = t;
int i = s;
for (int j = s; j <= t - 1; j++) {
// i < j ? -1
// 如果数据小于分区点，执行互换操作
if (((Comparable) data[j]).compareTo(data[point]) < 0) {
// 交换数据
swap(data, i, j);
// i向后移动一位，指向分区点
i += 1;
}
}
// 当结束后，将分区点的位置与i互换，即可完成
swap(data, i, point);
// System.out.println(Arrays.toString(data));
return i;
}
/**
* 进行数据交换操作
*
* @param data 原始数据
* @param src 原始位置
* @param target 目标位置
*/
private void swap(T[] data, int src, int target) {
T dataTmp = data[src];
data[src] = data[target];
data[target] = dataTmp;
}
}
分析快速排序的时间复杂度
最好情况时间复杂度
快速排序也是使用递归来实现的，在分析归并排序时，总结的公式同样适用，在最好情况下，每次都能将数据均匀的分成两个相同的区间，那快速排序与归并排序的时间复杂度是相同的
所以快排的最好情况时间复杂度就是O(nlogn)
t(1)=C 只需要常量级的执行时间,使用C表示
t(n)=2*t(n/2)+n n>1
平均情况下的时间复杂度
假设每次分区都将数据分成9：1的两个区间，继续套用公式来求解时间复杂度：
就会变成
t(1)=C t=1时，只需常量级的时间，表示为C
t(n)=t(9n/10)+t(n/10)+n n>1求解时间复杂度
t(n)=t(9n/10)+t(n/10)+n
（过程我还不能推导出来，目前空余）
只知道结果是n*logn
针对快速排序时间退化成O(n^2)的优化方法
优化方式1：三数取中
从待排序的数组中的头部、中间、还有尾部三个位置各取一个数，然后在这三个数中求出中位数，这种方法肯定比单纯的取固定值的方法要好，当要排序的数据很大时，三数取中可能就不够了，可能就会采用5数取中，或者更大的10数取中。
先还是来说三数取中法吧
首先对前两个数A和B进行比较大小，如果A大于B，则将A与换。
这时开始处理数C，数C处理在这里存在三种情况：
情况1：C小于A，那么A就是中位数
情况2：C大于A，小于B，那么C就是中位数
情况3：C大于B，那么B就是中位数。
代码实现:
/**
* 快速排序的代码实现,使用三数取中法进行分区点的选择操作
*
* @author liujun
* @version 0.0.1
* @date 2019/10/28
*/
public class QuickSortThirdMod<T> implements SortInf<T> {
@Override
public void sort(T[] data) {
if (data == null || data.length <= 1) {
return;
}
if (!(data[0] instanceof Comparable)) {
throw new IllegalArgumentException("data not implement compator interface");
}
// 调用快速排序
this.quickSort(data, 0, data.length - 1);
}
private void quickSort(T[] data, int s, int t) {
// 当前需操作元素仅一个，则退出
if (t - s < 1) {
return;
}
int point = this.partition(data, s, t);
quickSort(data, s, point - 1);
quickSort(data, point + 1, t);
}
/**
* 分区函数，在快速排序中使用的是原地分区，实现非常的巧妙
*
* <p>函数需要返回分区点
*
* @param data 原始数据
* @param s 开始位置
* @param t 结束位置
* @return 分区点的位置
*/
private int partition(T[] data, int s, int t) {
// 1,分区函数采用三数取中法
int countPoint = this.dataMid(data, s, t);
// 求得中位数后将，最后一个位置与中位数互换即可
swap(data, countPoint, t);
// 当前的分区点
int midPoint = t;
int i = s;
for (int j = s; j <= t - 1; j++) {
// i < j ? -1
// 如果数据小于分区点，执行互换操作
if (((Comparable) data[j]).compareTo(data[midPoint]) < 0) {
// 交换数据
swap(data, i, j);
// i向后移动一位，指向分区点
i += 1;
}
/// System.out.println("分区数据:" + Arrays.toString(data));
}
// 当结束后，将分区点的位置与i互换，即可完成
swap(data, i, midPoint);
// System.out.println("分区点:" + midPoint);
// System.out.println("分区完成后" + Arrays.toString(data));
return i;
}
/**
* 三数取中法
*
* <p>对三个数进行比较，然后交换次序
*
* @param data 数据
* @param s 开始索引
* @param t 结束索引
* @return 当前的中位数
*/
public int dataMid(T[] data, int s, int t) {
// 求两个数的中位数与(s+t)/2效果一致，但在接近最大数时，将不能运算，所以使用t+((s-t)>>1)
int midIndex = t + ((s - t) >> 1);
// 首先保证前两个数是有序的
if (((Comparable) data[s]).compareTo(data[midIndex]) > 0) {
swap(data, s, midIndex);
}
// 分为多种情况，情况1，比最小的数字小
if (((Comparable) data[t]).compareTo(data[s]) <= 0) {
return s;
}
// 情况2，大于最小，小于最大
else if (((Comparable) data[t]).compareTo(data[s]) > 0
&& ((Comparable) data[t]).compareTo(data[midIndex]) <= 0) {
return t;
}
// 情况3：大于最大的数，返回最大数
else {
return midIndex;
}
}
/**
* 进行数据交换操作
*
* @param data 原始数据
* @param src 原始位置
* @param target 目标位置
*/
private void swap(T[] data, int src, int target) {
T dataTmp = data[src];
data[src] = data[target];
data[target] = dataTmp;
}
}
优化方式2：随机
就是每次在要排序的数据区间中，随机选择一个点作为分区点，因为是随机挑选的，并不能保证每次挑选的分区点都比较合适，但从概率上来说，也不会每次挑选的分区点都很差。从而，退化到O(n^2)的情况非常的少
代码实现:
/**
* 快速排序的代码实现
*
* <p>使用随机分区点的方法
*
* @author liujun
* @version 0.0.1
* @date 2019/10/28
*/
public class QuickSortRandomPoint<T> implements SortInf<T> {
@Override
public void sort(T[] data) {
if (data == null || data.length <= 1) {
return;
}
if (!(data[0] instanceof Comparable)) {
throw new IllegalArgumentException("data not implement compator interface");
}
// 调用快速排序
this.quickSort(data, 0, data.length - 1);
}
private void quickSort(T[] data, int s, int t) {
// 当前需操作元素仅一个，则退出
if (t - s < 1) {
return;
}
int point = this.partition(data, s, t);
quickSort(data, s, point - 1);
quickSort(data, point + 1, t);
}
/**
* 分区函数，在快速排序中使用的是原地分区，实现非常的巧妙
*
* <p>函数需要返回分区点
*
* @param data 原始数据
* @param s 开始位置
* @param t 结束位置
* @return 分区点的位置
*/
private int partition(T[] data, int s, int t) {
// 1,采用随机的方法采用分区点，进行分区
int countPoint = ThreadLocalRandom.current().nextInt(s, t);
// 求得中位数后将，最后一个位置与中位数互换即可
swap(data, countPoint, t);
// 当前的分区点
int midPoint = t;
int i = s;
for (int j = s; j <= t; j++) {
// i < j ? -1
// 如果数据小于分区点，执行互换操作
if (((Comparable) data[j]).compareTo(data[midPoint]) < 0) {
// 交换数据
swap(data, i, j);
// i向后移动一位，指向分区点
i += 1;
}
}
// 当结束后，将分区点的位置与i互换，即可完成
swap(data, i, midPoint);
return i;
}
/**
* 进行数据交换操作
*
* @param data 原始数据
* @param src 原始位置
* @param target 目标位置
*/
private void swap(T[] data, int src, int target) {
T dataTmp = data[src];
data[src] = data[target];
data[target] = dataTmp;
}
}
快速排序的总结
| 算法名称 | 最好情况时间复杂度 | 最好情况的原始数据 | 最坏情况时间复杂度 | 最坏情况的原始数据 | 平均情况时间复杂度 | 是否基于比较 | 空间复杂度 | 是否稳定排序算法 |
|---|---|---|---|---|---|---|---|---|
| 快速排序 | O(nlogn) | 每次分区都分成大小相同的两个区间 | O(n^2) | 原始数据已经有序 | O(nlogn) | 是 | O(n)原地排序算法 | 非移定的原地排序算法 |
750
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
