排序算法之快速排序

• 简介
• 算法解析
• • 双循环
  • 单循环
• 代码实现
• • 测试调用

简介

快速排序是由冒泡排序演变而来，比冒泡排序更快的排序算法。之所以快，是因为快速排序用了分治法。

相同的是，与冒泡排序一样，快速排序也属于交换排序，通过元素之间的比较和交换来排序。

不同的是，冒泡排序每一轮只把一个元素冒泡到数列的一端，而快速排序每轮挑选一个基准元素，让比它小的元素移动到一端，让比它大的元素移动到另一端，从而把数列拆解成两个部分。

算法解析

双循环

1. 基准线选择：一般使用头节点的值作为基准线
2. 元素交换：使用两个下标，分别向中间移动，停止时进行元素交换
3. 分治：当循环结束，根据停止时的下标分割数组，递归调用
   

单循环

1. 基准线选择：一般使用头节点的值作为基准线
2. 元素交换：定义mark 标记，循环向右侧移动，直到元素比基准线小，则mark标记+1，并交换
3. 分治：当循环结束，根据停止时的下标分割数组，递归调用
   

代码实现

package com.zh.sort;
/**
* 快排分两种：
* 1. 双循环排序 ： 从列表两端循环
* 2. 单循环排序 ： 从列表一段循环
*/
public class QuickSort {
public void quickSort(int[] arr, int low, int high) {
if (low < high) {
// 找到基准值的位置
int pivotIndex = doublePartition(arr, low, high);
// 对基准值左边的子数组进行快速排序
quickSort(arr, low, pivotIndex - 1);
// 对基准值右边的子数组进行快速排序
quickSort(arr, pivotIndex + 1, high);
}
}
/**
* 双循环排序法
* @param arr
* @param low
* @param high
* @return
*/
private int doublePartition(int[] arr, int low, int high){
// 定义基准线
int p = arr[low];
// 左指针
int l = low;
// 右指针
int r = high;
while (l < r){
while (l < r && arr[r] >= p){
r--;
}
while (l < r && arr[l] <= p){
l++;
}
if (l < r){
swap(arr, l, r);
}
}
arr[low] = arr[l];
arr[l] = p;
return l;
}
/**
* 单循环排序法
* @param arr
* @param low
* @param high
* @return
*/
private int partition(int[] arr, int low, int high) {
// 选择最后一个元素作为基准值
int pivot = arr[low];
int mark = low;
for (int j = low + 1; j <= high; j++) {
// 如果当前元素小于基准值，则将其与i指向的元素交换位置
if (arr[j] < pivot) {
mark++;
swap(arr, mark, j);
}
printArr(arr);
}
// 将基准值放到正确的位置
arr[low] = arr[mark];
arr[mark] = pivot;
return mark;
}
private void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
private void printArr(int[] arr){
for (int num : arr) {
System.out.print(num + " ");
}
System.out.println(" ------------------- ");
}
}

测试调用

public static void main(String[] args) {
int[] arr = {3, 4, 2, 1, 5};
QuickSort qs = new QuickSort();
qs.quickSort(arr, 0, arr.length - 1);
for (int num : arr) {
System.out.print(num + " ");
}
}