LeetCode-215. Kth Largest Element in an Array

最新推荐文章于 2021-06-04 20:58:45 发布

原创最新推荐文章于 2021-06-04 20:58:45 发布 · 194 阅读

0 ·

CC 4.0 BY-SA版权

leetcode/heap 专栏收录该内容

7 篇文章

订阅专栏

本文介绍了解决LeetCode 215题“数组中的第K个最大元素”的几种方法，包括使用最大堆、最小堆、快速排序以及二叉堆等不同策略，并提供了详细的代码实现。

LeetCode-215. Kth Largest Element in an Array

Find the kth largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not the kth distinct element.

For example,
Given [3,2,1,5,6,4] and k = 2, return 5.

Note:

You may assume k is always valid, 1 ≤ k ≤ array's length.

解题思路：本题要求找出数组中第K个最大的元素，可以用堆排序的方法解决。STL中的二叉堆是通过名为priority_queue的类模板实现的，我们可以在标准的头文件queue中找到它。它的模板声明带有三个参数，priority_queue<Type, Container, Functional>，Type 为数据类型， Container 为保存数据的容器，Functional 为元素比较方式。Container 必须是用数组实现的容器，比如 vector, deque 但不能用 list。STL里面容器默认用的是 vector. 比较方式默认用operator<, 所以如果你把后面俩个参数缺省的话，优先队列就是最大堆。堆排序的时间复杂度O（NlogN）

最大堆实现

class Solution {
public:
	int findKthLargest(vector<int>& nums, int k) {
		priority_queue<int> pq(nums.begin(), nums.end());
		for (int i = 0; i < k - 1; i++)
			pq.pop();
		return pq.top();
	}
};

最小堆实现

class Solution {
public:
	int findKthLargest(vector<int>& nums, int k) {
		priority_queue<int, vector<int>, greater<int>> que;
		for (auto a : nums) {
			if (que.size() < k) {
				que.push(a);
			}
			else {
				if (a > que.top()) {
					que.pop();
					que.push(a);
				}
			}
		}
		return que.top();


	}
};

此题也可以用快速排序法，快速排序的思路就是选取一个元素作为枢纽元（pivot），将其他元素与pivot作比较，若大于pivot则将该元素放在左边，若小于则放在pivot的右边，排完一次后比较pivot的索引与K-1（第K个最大元素应该在的位置）的大小，若pivot大于K-1，则下一次快排的右端点放在pivot-1,若pivot小于K-1，则下一次快排的左端点放在pivot+1,直到最后pivot的索引为K-1位置。快速排序的时间复杂度在最坏情况下是O(N²)，平均的时间复杂度是O(N*lgN)

class Solution { 
public:
    int partition(vector<int>& nums, int left, int right) {
        int pivot = nums[left];
        int l = left + 1, r = right;
        while (l <= r) {
            if (nums[l] < pivot && nums[r] > pivot)
                swap(nums[l++], nums[r--]);
            if (nums[l] >= pivot) l++; 
            if (nums[r] <= pivot) r--;
        }
        swap(nums[left], nums[r]);
        return r;
    }
    
    int findKthLargest(vector<int>& nums, int k) {
        int left = 0, right = nums.size() - 1;
        while (true) {
            int pos = partition(nums, left, right);
            if (pos == k - 1) return nums[pos];
            if (pos > k - 1) right = pos - 1;
            else left = pos + 1;
        }
    }
};

最后附上LeetCode上实现二叉堆来进行堆排序的解决方法，该方法建立了一个最大二叉堆，然后逐渐删除堆在根处最大的元素，进行K-1次后，堆的根就是第K大的元素。

class Solution {
public:
	inline int left(int idx) {
		return (idx << 1) + 1;
	}
	inline int right(int idx) {
		return (idx << 1) + 2;
	}
	void max_heapify(vector<int>& nums, int idx) {
		int largest = idx;
		int l = left(idx), r = right(idx);
		if (l < heap_size && nums[l] > nums[largest]) largest = l;
		if (r < heap_size && nums[r] > nums[largest]) largest = r;
		if (largest != idx) {
			swap(nums[idx], nums[largest]);
			max_heapify(nums, largest);
		}
	}
	void build_max_heap(vector<int>& nums) {
		heap_size = nums.size();
		for (int i = (heap_size >> 1) - 1; i >= 0; i--)
			max_heapify(nums, i);
	}
	int findKthLargest(vector<int>& nums, int k) {
		build_max_heap(nums);
		for (int i = 0; i < k; i++) {
			swap(nums[0], nums[heap_size - 1]);
			heap_size--;
			max_heapify(nums, 0);
		}
		return nums[heap_size];
	}
private:
	int heap_size;
};

multiset方法实现，multiset从小到大排列

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        multiset<int> mset;
        int n = nums.size();
        for (int i = 0; i < n; i++) { 
            mset.insert(nums[i]);
            if (mset.size() > k)
                mset.erase(mset.begin());
        }
        return *mset.begin();
    }
};