点赞👍👍收藏🌟🌟关注💖💖
你的支持是对我最大的鼓励,我们一起努力吧!😃😃
1.分治
分治思想就如同它的名字一样:分而治之。
将一个大问题划分成若干个相同或者相识的子问题。然后在将子问题在划分成若干个相同或者相识的子问题,直到划分到不能在划分。然后解决子问题,子问题都解决完了,大问题也就被解决完了。快速排序和归并排序就用的分治思想。
以前我们学快速排序是在数组中选择一个基准元素,然后将数组分成左右两个区间,左区间比基准元素小,右区间比基准元素大。然后递归的去左区间和有区间排序,这种做法是将数组分成了两份。但是对于重复元素非常多的数组即使使用快速排序也会超时。因此这里我们学习新的划分方法,将数组划分成三份。
还是选一个基准元素将数组划分成三份,左区间元素都比基准元素小。中间区间元素和基准元素相同,右区间元素都比基准元素大。因为中间都是等于key的一定就是在最终位置,所以接下来递归还是只考虑左区间和右区间。
2.颜色分类
题目链接:75. 颜色分类
题目分析:
说起来这道题并不是真正的分治快速排序,而是把数组按照一定规则划分成三块的。当把这道题解决后,快排写的就非常简单。
这道题就相当于选择一个基准元素1,把小于1的放左边,大于1的放右边,等于1的放中间。
算法原理:
双指针可以将数组分成两块,具体怎么分,双指针系列第一道题移动零。这里我们需要三个指针将数组分成三块!
每个指针的作用:
i指针:遍历整个数组
left:标记 0 区域的最右侧
right:标记 2 区域的最左侧
三个指针将数组分成4份:
[0,left] :全都是0
[left+1,i-1]:全都是1
[i,right-1]:待扫描的元素
[rigth+1,n-1]:全都是2
接下来就讨论nums[i]是0或1或2应该怎么办?
当nums[i]为0的时候,要把0加入到左边区域,left指向的是 0 最右侧区域,此时left+1,然后将 i 位置和 left+1 元素交换,然后i+1。
还有一种极端情况 i 就在 left+1的为位置,并且正好是0。但是这种处理方法和上面一样。
当nums[i]为1的时候,i 指针往后走就行了
当nums[i]为2的时候,我们要将2加入到右边区间,也就是加入到 right - 1 的位置。交换 i 位置和 right -1 位置的元素。但是此时需要注意的是 交换给 i 位置的元素是待扫描的元素,因此 i 指针不能往后走!
class Solution {
public:
void sortColors(vector<int>& nums) {
int n = nums.size();
int i = 0, left = -1, right = n;
while(i < right)
{
if(nums[i] == 0)
swap(nums[++left], nums[i++]);
else if(nums[i] == 2)
swap(nums[--right], nums[i]);
else
++i;
}
}
};
3.排序数组
题目链接:912. 排序数组
题目描述:
算法原理:
在数组中选择一个基准元素key,根据key将数组分成左右区间,左区间元素小于等于key,右区间元素大于key。这个key就处于排序的最终位置。然后在将左区间排排序,右区间排排序,重复上述过程。整体就有序了。时间复杂度(nlogn)
但是如果数组都是重复元素,此时选择基准元素间将数组分成左右两区间就不行了。时间复杂度退化成O(n^2)
所以我们学习一个更优的做法,将 数组分三块 思想来实现快速排序
我们先选一个基准元素key,将数组分成三块。左区间小于key,中间区间等于key,右区间大于key。中间区间已经在排序后的最终位置,所以只用去去左区间排序,右区间排序。重复上述过程,整体就有序了。
数组如何分三块和颜色分类一模一样。定义一个i 指针 扫描数组,left指针 指向左区间小于key的最右侧, right指针 指向右区间大于key的最左侧。然后分情况讨论就好了。
即使数组全部都是重复元素,我们经过一次数组划分,整个数组都是中间区间,左右区间不存在,也不用在递归下去了,直接结束。时间复杂度O(n)
优化:用随机的方式选择基准元素
之前常用的三数取中,还是不够随机。要想时间复杂度逼近O(nlogn)就要用随机的方式选择基准元素。
随机选择就是让数组中每个元素被选择的概率相同,然后返回被选择的元素。
使用产生随机数的函数 rand(),让生成的随机数%这个区间的长度,然后加上left,这是在这个区间内的随机数的下标,然后返回对应下标的元素。
class Solution {
public:
vector<int> sortArray(vector<int>& nums) {
srand((unsigned int)time(nullptr));
QuickSort(nums,0,nums.size()-1);
return nums;
}
void QuickSort(vector<int>& nums, int l, int r)
{
if(l >= r) return;
//数组分三块
int key = getRandom(nums, l ,r);
int i = l, left = l - 1, right = r + 1;
while(i < right)
{
if(nums[i] < key)
swap(nums[++left], nums[i++]);
else if(nums[i] == key)
++i;
else
swap(nums[--right], nums[i]);
}
QuickSort(nums, l , left);
QuickSort(nums, right, r);
}
int getRandom(vector<int>& nums, int left, int right)
{
return nums[rand() % (right - left + 1) + left];
}
4.数组中的第K个最大元素
题目链接:215. 数组中的第K个最大元素
题目分析:
给定整数数组 nums 和整数 k,请返回数组中第 k 个最大的元素。其实就是一个TopK问题。
TopK问题四种问法:
第 k 个最大的元素
第 k 个最小的元素
前 k 个最大的元素
前 k 个最小的元素
可以使用堆排序, 时间复杂度O(nlogn)
还有一种就是快速选择算法,快速选择算法是基于快排实现的。时间复杂度O(n)。
算法原理:
一定要把数组分三块+随机选择基准元素掌握,才能懂这道题。
核心操作还是选择一个基准元素key,将数组分成< key , = key ,> key 三块区域。在这道题中我们是要找到第K大元素,这个第K大元素有可能落在三个区域中的任何一个区域。如果有一种方法能够确定第K大元素能够落在那个区域,那另外两个区域就不用考虑了。仅需在确定的区域里面递归找。所以说它是比快排更快的一种算法。
接下来重点就是如何确定第K大元素落在左边区域、中间区域、还是右边区域。
此时我们先统计出每个区域中元素的个数,假设左边区域元素个数为 a,中间区域元素个数为 b,右边区域元素个数为 c。
此时就分三种情况讨论:
因为求第K大,所以可以先考虑右边区域,因为右边区域都是大元素聚集地,第K大最有可能在右边区域。
- 第一种情况:如果第K大是落在右边区域,此时 c >= K,因为c表示大元素有多少个,而K表示找第K大的元素。如果 c >= K ,那第K大一定是落在右边区域。此时我们仅需到[right,r],找第K大。
- 第二种情况:如果到了第二情况那第一种情况一定是不成立的。如果第K大是落在中间区域,此时 b + c >= K,又因为第一种情况不满足,所有第K大一定是落在中间区域。此时就找到了也不用递归了。直接返回就可以。
- 第三种情况:第一、第二种情况全部不成立,第K大一定落在左边区域,去**[l,left]找**,但是此时并不是去找第K大了,本来是想在整个区间找第K大,但是第K大元素确定不在中间区域和右边区域,中间和右边区域都要被抛弃,此时去找左边区间找的是第 K - b - c 大的元素
class Solution {
public:
int findKthLargest(vector<int>& nums, int k) {
srand((unsigned int)time(nullptr));
return QuickSort(nums,0,nums.size()-1,k);
}
int QuickSort(vector<int>& nums, int l, int r, int k)
{
//不用考虑区间不存在的情况,因为下面的判断K落在那个区域,只要满足进入的一定是有的
if(l == r) return nums[l];
// 1.随机选择基准元素
int key = GetRandom(nums, l, r);
// 2.根据基准元素将数组分三块
int i = l, left = l - 1, right = r + 1;
while(i < right)
{
if(nums[i] < key) swap(nums[++left], nums[i++]);
else if(nums[i] == key) ++i;
else swap(nums[--right], nums[i]);
}
//3.计算每个区间都有多少元素,然后选择区间递归
int b = right - 1 - left , c = r - right + 1;
if(c >= k) return QuickSort(nums, right, r ,k);
else if(b + c >= k) return key;
else return QuickSort(nums, l, left, k - b - c);
}
int GetRandom(vector<int>& nums, int left, int right)
{
return nums[rand() % (right - left + 1) + left];
}
// int findKthLargest(vector<int>& nums, int k) {
// //前k个建小堆
// priority_queue<int,vector<int>,greater<int>> pq(nums.begin(),nums.begin()+k);
// //N-k与堆顶元素比较,大于堆顶就入堆,再次调整成小堆
// for(size_t i=k;i<nums.size();++i)
// {
// if(nums[i]>pq.top())
// {
// pq.pop();
// pq.push(nums[i]);
// }
// }
// return pq.top();
// }
};
5.库存管理 III
题目链接:LCR 159. 库存管理 III
题目分析:
实际上这也是一个TopK问题,让找前K个最小元素。注意返回结果并不考虑顺序问题。
算法原理:
解法一:排序 ,时间复杂度O(nlogn)
解法二:堆 ,时间复杂度O(nlogk)
解法三:快速选择算法,时间复杂度O(n)
数组分三块+随机选择基准元素。
选择一个基准元素key,将数组分成< key , = key ,> key 三块区域。找前K个最小的元素,落在三个区域中任何一个。统计除每个区域元素个数,然后选择去那个区域找。
分三种情况:
因为前K下最小元素最有可能出现在左边区域,因此先判断左边区域
- a >= K ,去[l,left] 找前K个最小元素
- b + a >= K ,直接返回
- 1、2都不成立,去[right,r] 找 K - a - b 个最小元素
class Solution {
public:
vector<int> inventoryManagement(vector<int>& nums, int k) {
srand((unsigned int)time(nullptr));
QuickSort(nums, 0, nums.size() - 1, k);
return {nums.begin(),nums.begin() + k};
}
void QuickSort(vector<int>& nums, int l, int r, int k)
{
if(l >= r) return;
// 1. 随机选择基准元素
int key = GetRandom(nums, l, r);
// 2. 数组分三块
int i = l, left = l - 1, right = r + 1;
while(i < right)
{
if(nums[i] < key) swap(nums[++left], nums[i++]);
else if(nums[i] == key) ++i;
else swap(nums[--right], nums[i]);
}
// 3. 分情况讨论
int a = left - l + 1, b = right - left - 1;
if(a >= k) QuickSort(nums, l, left, k);
else if(a + b >= k) return;
else QuickSort(nums, right, r, k - a - b);
}
int GetRandom(vector<int>& nums, int left, int right)
{
return nums[rand() % (right - left + 1) + left];
}
};