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

最新推荐文章于 2024-11-21 07:18:17 发布

csdnyq

最新推荐文章于 2024-11-21 07:18:17 发布

阅读量74

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode-数据结构和算法

本文链接：https://blog.youkuaiyun.com/csdnyq/article/details/100899380

leetcode-数据结构和算法专栏收录该内容

42 篇文章

订阅专栏

本文探讨了在未排序数组中寻找第K个最大元素的有效方法，包括通过快速排序直接查找和利用快速选择算法进行优化。通过示例展示了不同场景下两种方法的应用，为解决此类问题提供了清晰的思路。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

题目描述

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

示例 1:

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5

示例 2:

输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4

说明:

你可以假设 k 总是有效的，且 1 ≤ k ≤ 数组的长度。

思路1

先排序，再找出第K个最大元素。这里的排序使用快排。

实现1

class Solution {
    public int findKthLargest(int[] nums, int k) {
        sort(nums);
        return nums[nums.length - k];
    }
    
    private void sort(int[] arr) {
        sort(arr, 0, arr.length - 1);
    }
    
    private void sort(int[] arr, int low, int high) {
        if(high <= low) return;
        
        int j = partition(arr, low, high);
        
        sort(arr, low, j - 1);
        sort(arr, j + 1, high);
    }
    
    private int partition(int[] arr, int low, int high) {
        int pivot = arr[low];
        int i = low;
        int j = high + 1;
        
        while(true) {
            while(arr[++i] < pivot) {
                if(i == high) break;
            }
            
            while(arr[--j] > pivot) {
                if(j == low) break;
            }
            
            if(j <= i) break;
            
            swap(arr, i, j);
        }
        
        swap(arr, low, j);
        return j;
    }
    
    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

思路2

快速选择

实现2

class Solution {
    public int findKthLargest(int[] nums, int k) {
        int NthMin = nums.length - k;
        return findKthLargest(nums, NthMin, 0, nums.length - 1);
    }
    
    public int findKthLargest(int[] nums, int NthMin, int low, int high) {
        if(low == high) {
            return nums[low];
        }
        
        int j = partition(nums, low, high);
        
        if(j == NthMin) {
            return nums[j];
        } else if(j > NthMin) {
            return findKthLargest(nums, NthMin, low, j - 1);
        } else {
            return findKthLargest(nums, NthMin, j + 1, high);
        }

    }
    
    private int partition(int[] arr, int low, int high) {
        int pivot = arr[low];
        int i = low;
        int j = high + 1;
        
        while(true) {
            while(arr[++i] < pivot) {
                if(i == high) break;
            }
            
            while(arr[--j] > pivot) {
                if(j == low) break;
            }
            
            if(j <= i) break;
            
            swap(arr, i, j);
        }
        
        swap(arr, low, j);
        return j;
    }
    
    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}