LeetCode 215 Kth Largest Element in an Array

Kth Largest Element in an Array

思路

1. 快速排序
   每一轮快速排序，必将所选pivot放置在正确的位置。因为快速排序的原理是，该位置前面的元素都小于pivot，该位置后面的元素都大于pivot。

2. 标准库 nth_element
   该标准库函数接受一个范围，和一个指向该范围内元素的指针。该指针所指向的元素变更为最终有序序列在该位置的元素。

3. 标准库 partial_sort
   该标准库函数接受一个范围[first, last)，和一个在该范围内的指针mid。使得[first, mid)为最终有序序列的元素。该函数对相等的元素是unstable的。

4. 堆排序
   建立大顶堆，将前k-1个元素弹出去，此时留在堆顶的元素便是结果。

代码

快速排序

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        --k;
        
        int left = 0, right = nums.size() - 1, mid = quickSort(nums, left, right);
        
        while (mid != k) {
            if (mid < k) {
                left = mid + 1;
                mid = quickSort(nums, left, right);
            }
            else {
                right = mid - 1;
                mid = quickSort(nums, left, right);
            }
        }
        
        return nums[k];
    }

private:
    int quickSort(vector<int> &nums, int left, int right) {
        int start = left, pivot = nums[left];
        
        while (left < right) {
            while (nums[right] <= pivot && left < right) --right;
            while (nums[left] >= pivot && left < right) ++left;
            if (left < right) swap(nums[left], nums[right]);
            else swap(nums[start], nums[left]);
        }
        
        return left;
    }
};

nth_element

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        nth_element(nums.begin(), nums.begin() + k - 1, nums.end(), greater<int>());
        return nums[k - 1]; 
    }
};

partial_element

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        partial_sort(nums.begin(), nums.begin() + k, nums.end(), greater<int>());
        return nums[k - 1];
    }
};

堆排序

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        buildHeap(nums);
        for (int i = 0; i < k - 1; ++i) {
            swap(nums[0], nums[--heapSize]);
            heapify(nums, 0);
        }
        
        return nums[0];
    }

    
private:
    int heapSize;
    
    void buildHeap(vector<int> &nums) {
        heapSize = nums.size();
        int lastNode = heapSize - 1;
        int parent = (lastNode - 1) >> 1;
        for (int i = parent; i >= 0; --i) 
            heapify(nums, i);
    }
    
    void heapify(vector<int> &nums, int i) {
        if (i >= heapSize) return ;
        
        int max = i, leftNode = (i << 1) + 1, rightNode = (i << 1) + 2;
        if (leftNode < heapSize && nums[max] < nums[leftNode])
            max = leftNode;
        if (rightNode < heapSize && nums[max] < nums[rightNode])
            max = rightNode;
        
        if (max != i) {
            swap(nums[i], nums[max]);
            heapify(nums, max);
        }
    }
};