快速排序讲解与剑指 Offer 40最小的k个数的题解（java与js）

最新推荐文章于 2024-06-12 10:00:23 发布

M_emory_

最新推荐文章于 2024-06-12 10:00:23 发布

阅读量92

点赞数

分类专栏：算法文章标签：排序算法算法

本文链接：https://blog.csdn.net/M_emory_/article/details/129159895

版权

算法专栏收录该内容

9 篇文章 0 订阅

订阅专栏

快速排序的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据比另一部分的所有数据要小，再按这种方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，使整个数据变成有序序列。

快速排序过程的三个步骤:

(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);

力扣题解

剑指 Offer 40. 最小的k个数

这道题最简单的解题思路就是利用内置函数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);
}

好了，这就是快排的基本思路，排序的方法有很多种，快排算是很常用的一种排序，只要勤加练习就可以熟练掌握。