LeetCode：215. 数组中的第K个最大元素——快速排序

🍎道阻且长，行则将至。🍓

---

🌻算法，不如说它是一种思考方式🍀

算法专栏： 👉🏻123

---

一、🌱215. 数组中的第K个最大元素

• 题目描述：给定整数数组nums和整数** k**，请返回数组中第 k 个最大的元素。
  请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。
• 来源：力扣（LeetCode）
• 难度：中等
• 提示：
  1 <= k <= nums.length <= 105
  -104 <= nums[i] <= 104

本题也出现在剑指offer II： 076. 数组中的第 k 大的数字，不过测试案例更友好。

🌴解题

对于本题最常规的解法就是先大到小排序，然后返回第k个元素即可，时间复杂度越低越好。
对于友好的测试案例，也可以使用大小为k的数组进行一次目标变量存储前k大的数。

1.排序法

1.1冒泡排序

最简单的是冒泡排序，方法非常简单，使用两层循环进行逐一遍历，时间复杂度为O(n²)。参考：冒泡排序☝

1.2快速排序

在这个题目要求的==O(n)==时间复杂度，冒泡法是无法通过的，因此考虑快一点的排序算法：快速排序。（大到小为例）
快速排序最直观的理解就是每次选择的key元素（或者基准）经过一趟排序后放在了最终所在的位置，也就是左边大于key元素，右边小于key元素。于是数组被区分为了两个子区间，再继续在两个子区间用同样的方法。这也被称之为分治策略，就是把大的问题变成一个个小的问题，最后组合起来。
例如数组：{4,2,3,5,6,1}，对于其中的一次排序：

我们选取第一个元素为了key，下一个为p，最后一个为q。step1.q向左遍历，遇到大于key的元素的位置停下来，step2.p向右遍历，遇到小于key的停下来，然后交换pq的元素值。一直重复直到pq相遇，与key交换结束：

这是其中一种方法，还有挖坑填数、快慢指针：

• 挖坑填数
  挖坑填数就是在上一个方法的基础上来的，选择的key元素先挖出来，q指针往左走发现大于key时就把这个元素挖出来，填到上一个坑里，于是新坑出现了；然后p向右走，遇到小于key的也挖出来，填到上一个坑里，一直这样的过程，直到pq相遇，将key最后填入这个坑里。（指针是一直向坑遍历）

• 快慢指针fast、slow
  前面两种方法的指针都是从两端向中间，该方法的指针都是从左至右：都是从key的下一位往右走，快指针每走一步都会判断其指向的元素是否大等于key，若小于则交换两个指针的元素，并且让慢指针移动1位；直到fast遍历完全，slow退回一步（预期的向前了一步），交换slow和key。

快速排序和冒泡排序解题code:

class Solution076 {
    public static int findKthLargest(int[] nums, int k) {
        //排序
       // bobosort(nums);
        //快速排序
        fastsort(nums);


        return nums[k-1];
    }

    private static void fastsort(int[] nums) {
        int left=0,right= nums.length-1;
        myquicksort(nums,left,right);

    }
    private static void myquicksort(int[] nums, int left, int right) {
        if(left>right)
            return;
        int key=partsort(nums,left,right);
        myquicksort(nums,left,key-1);
        myquicksort(nums, key+1, right);
    }
    private static int partsort(int[] nums, int left, int right) {
        int key=left;
        while(left<right){
            while(left<right&&nums[right]<=nums[key])
                right--;
            while(left<right&&nums[left]>=nums[key])
                left++;
            myswap(nums,left,right);
        }
        myswap(nums,key,left);
        return left;
    }
    private static void myswap(int[] nums, int left, int right) {
        int tem;
        tem=nums[left];
        nums[left]=nums[right];
        nums[right]=tem;
    }


    public static int[] bobosort(int[] nums){
        int tem;
        for (int i = 0; i < nums.length-1; i++) {
            for (int j = i+1; j < nums.length; j++) {
                if(nums[i]<nums[j]){
                    tem=nums[i];
                    nums[i]=nums[j];
                    nums[j]=tem;
                }
            }
        }

        return nums;
    }

}

1.3快速排序思想简化本题

在前面就发现，本题其实找到某个位置之后的一些步骤不需要进行了，例如我们找第8个大的数，在第1次找到第六个元素，那么第8大的元素必然是在后面部分，前面部分数组就可以不管了；当刚好找到第8个时直接返回就是我们的结果。这样可以大大减少搜索时间。

• code：

class Solution {
    publicint findKthLargest(int[] nums, int k) {
        int key=0;
        int left=0;
        int right= nums.length - 1;
        quicksort1(nums,key,left,right,k-1);

        return nums[k-1];
    }

    private static void quicksort1(int[] nums, int key, int left, int right, int k) {
        if(left>right)
            return;
        key = partsort( nums,  key,  left,  right);
        if(key<k){
            quicksort1(nums,key+1,key+1,right,k);

        }else if(key==k){
            return;
        }else{
            quicksort1(nums,left,left,key-1,k);
        }
    }

    private static int partsort(int[] nums, int key, int left, int right) {
        int slow=key+1;
        int fast=key+1;

        int temp;
        while (fast<=right){

            if(nums[fast]>=nums[key]){
                temp=nums[slow];
                nums[slow]=nums[fast];
                nums[fast]=temp;
                slow++;
            }
            fast++;
        }
        slow--;
        temp=nums[key];
        nums[key]=nums[slow];
        nums[slow]=temp;
        return slow;
    }
}

2.大小为k数组

就是说使用一个大小为k的数组来存储遍历找到前k个最大的数，只需要遍历一遍数组，但是数组k的处理还是需要耗费时间的。

• code：

class Solution076 {
    public static int findKthLargest(int[] nums, int k) {
        int[] numk = new int[k];
        int j=0;
        for (int i = 0; i < nums.length; i++) {
            if(i<k){
                numk[i]=nums[i];
            }else{
                j=findKless(numk);
                if(numk[j]<nums[i])
                    numk[j]=nums[i];
            }
        }
        j=findKless(numk);

        return numk[j];
    }

    public static int findKless(int[] nums){
        int k=0;
        for (int i = 1; i < nums.length; i++) {
            if(nums[k]>nums[i])
                k=i;
        }
        return k;
    }
}

该方法只能通过剑指offer的案例：
t215

剑指offer：

---

🌵Bug本是code常态，通过才是稀缺的意外！🌷

返回第一页☝

---

---

☕物有本末，事有终始，知所先后。🍭

🍎☝☝☝☝☝我的CSDN☝☝☝☝☝☝🍓