快速排序详解(符java代码)
1.算法思想
-
从待排序区间选择一个数,作为基准值(pivot);
-
Partition: 遍历整个待排序区间,将比基准值小的(可以包含相等的)放到基准值的左边,将比基准值大的(可 以包含相等的)放到基准值的右边;
-
采用分治思想,对左右两个小区间按照同样的方式处理,直到小区间的长度 == 1,代表已经有序,或者小区间 的长度 == 0,代表没有数据。
private static void quickSort(int[] arr, int left, int right) {
if (left > right) {//表示已经有序
return;
}
int partition = partition(arr, left, right);
//得到的partition左边全是小于等于它的数,右边全是大于它的数
quickSort(arr, left, partition-1);//对partition左边进行快排
quickSort(arr, partition+1, right);//对partition右边进行快排
}
2.实现partition思路
2.1 honor法
- 先从右往左找到一个比基数小的数, 再从左往右找到一个比基数大的数
- 交换两个数 ,然后继续执行1,2操作。
- 最后交换right指针和基数指针所指的数
- 注意! 如果取第一个数为基数时,一定要先从右找
private static int partition1(int[] arr, int left, int right) {
int base = left; //用于比较的基数下标
while (left < right) {//先从右向左找比基数小的数
while (left < right && arr[right] >= arr[base]) {
right--;
}
while (left < right && arr[left] <= arr[base]) {//再从左向右找比基数大的数
left++;
}
if (left < right) {
swap(arr, left, right);//然后交换
}
}
swap(arr, base, right);//最后交换基数和right
return right;
}
//用于交换的函数
private static void swap(int[] arr, int left, int right) {
int temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
}
2.2 挖坑法
基本思路和honor 法一致,只是不再进行交换,而是进行赋值(挖坑和填坑的过程)
private static int partition2(int[] arr, int left, int right) {
int base = arr[left]; //1.先把用于比较的基数挖出来
while (left < right) {
//2.从右向左找小于base的数填入坑
while (left < right && arr[right] >= base) {
right--;
}
arr[left] = arr[right];
//2.从左向右找大于base的数填入坑
while (left < right && arr[left] <= base) {
left++;
}
arr[right] = arr[left];
}
//4.最后将base填入坑
arr[right] = base;
return right;
}
因为没有用到swap函数,只是在本身的数组位置上挖坑填坑,所以更加高效,算是honor法的优化版本
2.3 前后下标法
思路:用前后两个下标指针包括的范围来表示比基数大于等于的数,该范围以外的数就是比基数要小的数
private static int partition3(int[] arr, int left, int right) {
int separateIndex = left + 1;//范围的尾部指针
for (int i = left + 1; i <= right; i++) {
// 1.当遇到比基数小的数才做处理 处理方法为
// 把separateIndex和当前数交换,然后separateIndex++
if (arr[i] < arr[left]) {
swap(arr, separateIndex, i);
separateIndex++;
}
}
//最后再把基数和separateIndex - 1下标元素交换
swap(arr, separateIndex - 1, left);
return separateIndex - 1;
}
3.算法分析
3.1 性能分析
时间复杂度 空间复杂度 稳定性:
最好 平均 最坏 最好 平均 最坏
O(n * log(n)) O(n * log(n)) O(n^2) O(log(n)) O(log(n)) O(n) 不稳定
3.2 优化分析
- 小细节优化, 比如i从left+1开始,尽可能的使用最少的变量等
- 基点的选择,最坏情况 如所有元素一样时,选择最左边元素为基点,就会造成算法将执行partition n次,时间复杂度是O(n^2), 为了避免这种情况,我们可以对基点的选择进行优化 ①可以随机选择 ②可以三点取中
- partition过程中 相等的特殊处理 ,使得相等的元素不需要再进行下一轮快排
- 待排序区间小于一个阈值时(例如 48),使用直接插入排序 (因为插入排序在数据量小的时候很快)
3.3 优化版本partition
- 定义一个less和more表示小于base的区间和大于base的区间
- 遍历过程中,遇到大于base的数,swap(arr, --more, left);
- 遇到小于base的数,swap(arr, ++less, left++);
- 遇到等于base的数,left++;
- 最后返回大于和小于区间边界return new int[]{less, more};
private static int[] partition4(int[] arr, int left, int right) {
int base = arr[right]; //用于比较的基数
int more = right + 1, less = left - 1;//大于base和小于base的区间边界
while (left < more) {
if (arr[left] > base) { //注意! 当前数比base大时 交换回来的数要重新判断
swap(arr, --more, left);
} else if (arr[left] < base) {
swap(arr, ++less, left++);
} else {
left++;
}
}
return new int[]{less, more};
}
4.最终版本代码实现(java)
public static void main(String[] args) {
int[] arr = new int[20];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) (Math.random() * 100);
}
System.out.println("排序前" + Arrays.toString(arr));
quickSort("排序后" + arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
private static void quickSort(int[] arr, int left, int right) {
if (left > right) {
return;
}
int[] partition = partition(arr, left, right);
quickSort(arr, left, partition[0]);
quickSort(arr, partition[1], right);
}
private static int[] partition(int[] arr, int left, int right) {
int base = arr[right]; //用于比较的基数
int more = right + 1, less = left - 1;//大于base和小于base的区间边界
while (left < more) {
if (arr[left] > base) { //注意! 当前数比base大时 交换回来的数要重新判断
swap(arr, --more, left);
} else if (arr[left] < base) {
swap(arr, ++less, left++);
} else {
left++;
}
}
return new int[]{less, more};
}
private static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
运行结果
排序前[15, 15, 20, 92, 55, 24, 57, 76, 8, 54, 81, 91, 94, 64, 31, 61, 10, 49, 75, 38]
排序后[8, 10, 15, 15, 20, 24, 31, 38, 49, 54, 55, 57, 61, 64, 75, 76, 81, 91, 92, 94]