快速排序的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据比另一部分的所有数据要小,再按这种方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,使整个数据变成有序序列。
快速排序过程的三个步骤:
(1)在数据集之中,选择一个元素作为"基准"(pivot)
(2)所有小于"基准"的元素,都移到"基准"的左边;所有大于"基准"的元素,都移到"基准"的右边
(3)对"基准"左边和右边的两个子集,不断重复第一步和第二步,知道所有的子集只剩下一个元素为止
直接上代码
基本快速排序
java代码
public class QuickSort {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int i = scanner.nextInt();
int[] arr = {3,2,1,5,6,4};
int left = 0;
int right = arr.length - 1;
quickSort(arr,left,right);
System.out.println(Arrays.toString(arr));
}
// 定义一个交换(swap)方法,用于交换两个数的位置
private static void swap(int[] arr,int i,int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
// 定义一个快速排序的方法
private static void quickSort(int[] arr,int left,int right){
// 当开始的值小于等于结束的值的时候,直接停止程序的运行
if(left >= right){
return;
}
// 定义一个基准值
int prvot = arr[left];
// 定义需要排序数组的左右边界
int i = left + 1,j = right;
while(true){
// 判断如果左边的值小于基准值,就让 i 往前走,如果大于了基准值,就退出循环
while(i <= j && arr[i] <= prvot){
++i;
}
// 判断如果右边的值大于基准值,就让 j 往前走,如果小于了基准值,就退出循环
while(i <= j && arr[j] >= prvot){
--j;
}
// 如果此时 i >= j 的时候,就可以退出循环了
if(i >= j){
break;
}
// 判断一轮 i 与 j 之后,i 的值是比基准值大的值, j 是比基准值小的值,所以就需要交换 i 与 j 的位置
swap(arr,i,j);
}
// 当退出循环的时候,说明此时 i > j ,所以需要将基准值与 j 交换(此时 j 的前面都是比基准值小的数,所以将基准值放到这里就可以形成两个区间 )
swap(arr,left,j);
// 形成两个区间之后,就可以利用递归,将剩下两个区间再次执行先前的操作,直到每个区间都为一个数的时候,排序就完成了
quickSort(arr,left,j-1);
quickSort(arr,j+1 ,right);
}
}
js代码
// 定义一个交换(swap)方法,用于交换两个数的位置
function swap(arr, left, right) {
var temp = arr[left]
arr[left] = arr[right]
arr[right] = temp
}
// 定义一个排序的方法
function quickSort(arr, left, right) {
// 当 left 大于 right 的时候,直接退出
if (left > right) {
return
}
// 定义一个基准值
var pivot = arr[left]
// 定义左右区间
var i = left + 1
var j = right
while (true) {
// 判断如果左边的值小于基准值,就让 i 往前走,如果大于了基准值,就退出循环
while (i <= j && arr[i] <= pivot) {
i++
}
// 判断如果右边的值大于基准值,就让 j 往前走,如果小于了基准值,就退出循环
while (i <= j && arr[j] >= pivot) {
j--
}
// 如果此时 i >= j 的时候,就可以退出循环了
if (i >= j) {
break
}
// 判断一轮 i 与 j 之后,i 的值是比基准值大的值, j 是比基准值小的值,所以就需要交换 i 与 j 的位置
swap(arr, i, j)
}
// 当退出循环的时候,说明此时 i > j ,所以需要将基准值与 j 交换(此时 j 的前面都是比基准值小的数,所以将基准值放到这里就可以形成两个区间 )
swap(arr, left, j)
// 形成两个区间之后,就可以利用递归,将剩下两个区间再次执行先前的操作,直到每个区间都为一个数的时候,排序就完成了
// 此时的 j 是基准值,所以将基准值前面与后面分成两个区间
quickSort(arr, left, j - 1);
quickSort(arr, j + 1, right);
}
// 进行测试
var arr = [3, 2, 1, 5, 6, 4]
var left = 0
var right = arr.length - 1
quickSort(arr, left, right)
console.log(arr);
随机快速排序
当数组趋于有序时,例如 [1,2,3,4,5,6,7,9,8]
使用基本快排会先遍历1右边所有的数确定1的位置,然后遍历2右边所有的数确定2的位置……每次排定的基准值左侧无数值,此时的递归基本名存实亡了,最后时间复杂度由原来的O(nlogn)
坍缩为O(n^2)
。
所以我们引入随机基准数。
在每次使用left
确定基准数的之前,将left
与右方随机一个元素交换位置,然后再找随机基准值的正确位置,此时递归便可如期成立,利用空间换取时间。
java代码
// 快速排序
public class QuickSort {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int i = scanner.nextInt();
int[] arr = {3,2,1,5,6,4};
int left = 0;
int right = arr.length - 1;
quickSort(arr,left,right);
System.out.println(Arrays.toString(arr));
}
// 定义一个交换(swap)方法,用于交换两个数的位置
private static void swap(int[] arr,int i,int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
Random rand = new Random();
// 定义一个快速排序的方法
private static void quickSort(int[] arr,int left,int right){
// 当开始的值小于等于结束的值的时候,直接停止程序的运行
if(left >= right){
return;
}
// 定义一个随机数
int randIndex = left + rand.nextInt(right - left + 1);
// 将基准值与随机数进行交换
swap(arr, left, randIndex);
// 定义一个基准值
int prvot = arr[left];
// 定义需要排序数组的左右边界
int i = left + 1,j = right;
while(true){
while(i <= j && arr[i] <= prvot){
++i;
}
while(i <= j && arr[j] >= prvot){
--j;
}
if(i >= j){
break;
}
swap(arr,i,j);
}
swap(arr,left,j);
quickSort(arr,left,j-1);
quickSort(arr,j+1 ,right);
}
}
js代码
// 定义一个交换(swap)方法,用于交换两个数的位置
function swap(arr, left, right) {
var temp = arr[left]
arr[left] = arr[right]
arr[right] = temp
}
// 定义一个排序的方法
function quickSort(arr, left, right) {
// 当 left 大于 right 的时候,直接退出
if (left > right) {
return
}
// 定义一个随机数
var randIndex = parseInt(Math.random() * (right - left + 1) + left);
// 将基准数与随机数进行交换
swap(arr, left, randIndex)
// 定义一个基准值
var pivot = arr[left]
// 定义左右区间
var i = left + 1
var j = right
while (true) {
// 判断如果左边的值小于基准值,就让 i 往前走,如果大于了基准值,就退出循环
while (i <= j && arr[i] <= pivot) {
i++
}
// 判断如果右边的值大于基准值,就让 j 往前走,如果小于了基准值,就退出循环
while (i <= j && arr[j] >= pivot) {
j--
}
// 如果此时 i >= j 的时候,就可以退出循环了
if (i >= j) {
break
}
// 判断一轮 i 与 j 之后,i 的值是比基准值大的值, j 是比基准值小的值,所以就需要交换 i 与 j 的位置
swap(arr, i, j)
}
// 当退出循环的时候,说明此时 i > j ,所以需要将基准值与 j 交换(此时 j 的前面都是比基准值小的数,所以将基准值放到这里就可以形成两个区间 )
swap(arr, left, j)
// 形成两个区间之后,就可以利用递归,将剩下两个区间再次执行先前的操作,直到每个区间都为一个数的时候,排序就完成了
// 此时的 j 是基准值,所以将基准值前面与后面分成两个区间
quickSort(arr, left, j - 1);
quickSort(arr, j + 1, right);
}
// 进行测试
var arr = [3, 2, 1, 5, 6, 4]
var left = 0
var right = arr.length - 1
quickSort(arr, left, right)
console.log(arr);
力扣题解
这道题最简单的解题思路就是利用内置函数sort进行排序,但是为了练习快速排序,我用java和js对这道题进行了解答
java代码
import java.util.Random;
class Solution {
// 生成随机数的对象
Random rand = new Random();
public int[] getLeastNumbers(int[] arr, int k) {
int left = 0;
int right = arr.length - 1;
quickSort(arr,left,right);
// int[] arr2 = new int[k];
// for(int i = 0; i < k; i++){
// arr2[i] = arr[i];
// }
// return arr2;
return Arrays.copyOfRange(arr, 0, k);
}
// 定义一个快速排序的方法
private void quickSort(int[] arr,int left,int right){
// 当开始的值小于等于结束的值的时候,直接停止程序的运行
if(left >= right){
return;
}
// 定义一个随机数
int randIndex = left + rand.nextInt(right - left + 1);
// 将基准值与随机数进行交换
swap(arr, left, randIndex);
// 定义一个基准值
int prvot = arr[left];
// 定义需要排序数组的左右边界
int i = left + 1,j = right;
while(true){
while(i <= j && arr[i] <= prvot){
++i;
}
while(i <= j && arr[j] >= prvot){
--j;
}
if(i >= j){
break;
}
swap(arr,i,j);
}
swap(arr,left,j);
quickSort(arr,left,j-1);
quickSort(arr,j+1,right);
}
// 定义一个交换(swap)方法,用于交换两个数的位置
private void swap(int[] arr,int i,int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
js代码
/**
* @param {number[]} arr
* @param {number} k
* @return {number[]}
*/
var getLeastNumbers = function(arr, k) {
var left = 0;
var right = arr.length - 1;
quickSort(arr,left,right);
var arr2 = [];
for(let i = 0; i < k; i++){
arr2[i] = arr[i]
}
return arr2;
}
function swap(arr, left, right) {
var temp = arr[left]
arr[left] = arr[right]
arr[right] = temp
}
function quickSort(arr, left, right) {
if (left > right) {
return
}
var randIndex = parseInt(Math.random() * (right - left + 1) + left);
swap(arr, left, randIndex)
// 定义一个基准值
var pivot = arr[left]
// 定义左右区间
var i = left + 1
var j = right
while (true) {
while (i <= j && arr[i] <= pivot) {
i++
}
while (i <= j && arr[j] >= pivot) {
j--
}
if (i >= j) {
break
}
swap(arr, i, j)
}
swap(arr, left, j)
quickSort(arr, left, j - 1);
quickSort(arr, j + 1, right);
}
好了,这就是快排的基本思路,排序的方法有很多种,快排算是很常用的一种排序,只要勤加练习就可以熟练掌握。