数组中的第K个最大元素-排序215-C++&python

c++
堆排序的思想

class Solution {
public:
    
    void swap_element(vector<int>& a, int i, int heapsize){
        int l = i * 2 + 1;
        int r = i * 2 + 2;
        int current = i;
        if(l < heapsize && a[l] > a[current]){
            current = l;
        }
        if(r < heapsize && a[r] > a[current]){
            current = r;
        }
        if(current != i){
            swap(a[current], a[i]);
            swap_element(a, current, heapsize);
        }
    }

    void build_max_heap(vector<int>& a, int heapsize){
        for(int i = heapsize / 2; i >= 0; --i){
            swap_element(a, i, heapsize);
        }
    } 


    int findKthLargest(vector<int>& nums, int k) {
        int heapSize = nums.size();
        build_max_heap(nums, heapSize);
        for(int i = nums.size() - 1; i >= nums.size() - k + 1; --i){
            swap(nums[0], nums[i]);
            --heapSize;
            swap_element(nums, 0, heapSize);
        }
        return nums[0];
    }
};

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        // 堆排序
        int n = nums.size();
        // 建堆
        init_heap(nums, n);
        // 调整堆
        for (int i = 0; i < n; i++) {
            if (i == k-1) {
                return nums[0];
            }
            swap(nums[0], nums[n-i-1]);
            heapify(nums, 0, n-i-1);
        }
        
        return -1;
    }

    void init_heap(vector<int>& nums, int& n) {
        for (int i = n/2-1; i >=0; i--) {
            heapify(nums, i, n);
        }
    }

    void heapify(vector<int>& nums, int i, int n) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int largest = i;

        if (left < n && nums[left] > nums[largest]) {
            largest = left;
        }
        if (right < n && nums[right] > nums[largest]) {
            largest = right;
        }
        if (largest != i) {
            swap(nums[i], nums[largest]);
            heapify(nums, largest, n);
        }
    }
};

python
快排思想

import random

class Solution:
    def partition(self, arr, left, right):
        random_index = random.randint(left, right)
        arr[random_index], arr[right] = arr[right], arr[random_index]
        i = left - 1
        pviot = arr[right]

        for j in range(left, right):
            if arr[j] <= pviot:
                i += 1
                arr[i], arr[j] = arr[j], arr[i]
        
        arr[i+1], arr[right] = arr[right], arr[i+1]

        return i+1

    def findKthLargest(self, nums: List[int], k: int):
        size = len(nums)
        target = size - k
        left = 0
        right = size - 1

        while left <= right:
            i = self.partition(nums, left, right)
            
            if i == target:
                return nums[i]
            elif target < i:
                right = i-1
            elif target > i:
                left = i+1
        
        return -1