【LeetCode & 剑指offer刷题】查找与排序题2：40 最小的k个数（对应Kth Largest Element in an Array）
【LeetCode & 剑指offer 刷题笔记】目录（持续更新中...）
40 最小的k个数
题目描述
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,
/*
//暴力法：sort, O(nlogn)
//方法一：使用自带的stl函数
#include
using namespace std;
class Solution
{
public:
vector GetLeastNumbers_Solution(vector input, int k)
{
if(k<=0 || k > input.size()) return vector(); //处理非法输入
nth_element(input.begin(), input.begin()+k-1, input.end());
vector result(input.begin(),input.begin()+k); //构造结果向量
return result;
}
};*/
/*
/*掌握
方法一：基于partition函数(快排中有用到，stl中也有，但是还是自己实现较好)
多次partition直到枢轴位置为k即可
缺点：会改变输入数组的元素位置
平均O(n)，每次partition 平均O(n),次数未知，真的是O(n)吗，存疑？
思考：最好情况为O(n),最坏情况为O(n^2)（如对于倒序排列的数组）
通过优化partition，比如三数中值枢轴法或随机初始化枢轴法，可以改善时间复杂度
分析参考：
考虑最坏情况下，每次 partition 将数组分为长度为 N-1 和 1 的两部分，然后在长的一边继续寻找第 K 大，此时时间复杂度为 O(N^2 )。
不过如果在开始之前将数组进行随机打乱，那么可以尽量避免最坏情况的出现。
而在最好情况下，每次将数组均分为长度相同的两半，运行时间 T(N) = N + T(N/2)，时间复杂度是 O(N)。
参考：被忽视的 partition 算法
*/
#include
class
Solution
{
public
:
vector
<
int
>
GetLeastNumbers_Solution
(
vector
<
int
>
input
,
int
k
)
{
if
(
input
.
empty
()
||
k
<=
0
||
k
>
input
.
size
())
return
vector
<
int
>();
//处理异常输入
int
left
=
0
,
right
=
input
.
size
()-
1
;
int
pivot_pos
;
while
(
left
<=
right
)
//类似二分查找法
{
pivot_pos
=
partition
(
input
,
left
,
right
);
//如果要求最大的第k个数，可以对partition函数进行改造
if
(
pivot_pos
<
k
-
1
)
left
=
pivot_pos
+
1
;
else
if
(
pivot_pos
>
k
-
1
)
right
=
pivot_pos
-
1
;
else
break
;
//此题要求的是返回最小的前k个数，如果仅返回最小的第k个数，直接在这里return a[pivot_pos]即可
}
vector
<
int
>
result
(
input
.
begin
(),
input
.
begin
()+
k
);
//构造结果向量
return
result
;
}
private
:
int
partition
(
vector
<
int
>&
a
,
int
left
,
int
right
)
{
//随机初始化枢轴 5ms
//srand(time(nullptr)); //以当前时间为随机生成器的种子
//int pivotpos = rand()%(right - left + 1) + left; //产生【left,right】之间的数
//swap(a[pivotpos], a[left]); //将枢轴暂时放入起始位置
int
pivot
=
left
;
//枢轴位置 4ms
while
(
left
<
right
)
{
while
(
left
<
right
&&
a[right] >= a[pivot
])
right
--;
//找到本次扫描中第一个不满足枢轴规律的高位数
while
(
left
<
right
&&
a[left] <= a[pivot
])
left
++;
//找到本次扫描中第一个不满足枢轴规律的低位数
swap
(
a
[
left
],
a
[
right
]);
//交换以使满足枢轴规律
}
//最后结果是left和right均指向枢轴位置
swap
(
a
[
left
],
a
[pivot
]);
//将枢轴移动到位
return
left
;
//返回枢轴位置
}
};
//
/*掌握
方法二：使用堆或者红黑树（平衡二叉搜索树）
用容器存储k个数，遍历输入向量过程中不断更新容器内的数（如果当前数小于容器中的最大值，则插入该数，删除原最大数）
优点：不需要修改输入数组，且适用于处理海量输入数据
O(nlogk)
*/
class
Solution
{
public
:
vector
<
int
>
GetLeastNumbers_Solution
(
vector
<
int
>
input
,
int
k
)
{
if
(
input
.
empty
()
||
k
<=
0
||
k
>
input
.
size
())
return
vector
<
int
>();
//处理异常输入
//仿函数中的greater模板，从大到小排序(默认从小到大，左结点<父结点<根结点)
multiset
<
int
,
greater
<
int
>>
leastNums
;
//用红黑树存储这k个数
for
(
int
ai
:
input
)
{
if
(
leastNums
.
size
()
<
k
)
leastNums
.
insert
(
ai
);
//将前k个元素插入容器
else
{
//第一个数为最大数
multiset
<
int
,
greater
<
int
>>::
iterator greatest_it
=
leastNums
.
begin
();
//如果后续元素小于第一个元素，删除第一个，加入当前元素
if
(
ai
<
*
greatest_it
)
{
leastNums
.
erase
(
greatest_it
);
//删除原最大值
leastNums
.
insert
(
ai
);
//插入新元素(logk复杂度)
}
}
}
return
vector<int>(leastNums.begin(), leastNums.end()); //返回结果向量(前k个最小的数)
}
};
Kth Largest Element in an Array
Find the
k
th largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not the kth distinct element.
Example 1:
Input:
[3,2,1,5,6,4]
and k = 2
Output:
5
Example 2:
Input:
[3,2,3,1,2,4,5,5,6]
and k = 4
Output:
4
Note:
You may assume k is always valid, 1 ≤ k ≤ array's length.
C++
暴力法：直接sort,O(nlogn)，leetcode用时12ms
/*掌握
方法一：基于partition函数(快排中有用到，stl中也有，但是还是自己实现较好)
多次partition直到枢轴位置为k即可
缺点：会改变输入数组的元素位置
leetcode 耗时4ms,若用pivot = left的做法，则耗时20ms
平均O(n)，O(1)
每次partition 平均O(n),次数未知，真的是O(n)吗，存疑？
思考：最好情况为O(n),最坏情况为O(n^2)（如对于倒序排列的数组）
通过优化partition，比如三数中值枢轴法或随机初始化枢轴法，可以改善时间复杂度
*/
#include
class
Solution
{
public
:
int
findKthLargest
(
vector
<
int
>&
a
,
int
k
)
{
if
(
a
.
empty
()
||
k
<=
0
||
k
>
a
.
size
())
return
0
;
//处理异常输入
int
left
=
0
,
right
=
a
.
size
()-
1
;
int
pivot_pos
;
while
(
left
<=
right
)
//类似二分查找法
{
pivot_pos
=
partition
(
a
,
left
,
right
);
//如果要求最大的第k个数，可以对partition函数进行改造
if
(
pivot_pos
<
k
-
1
)
left
=
pivot_pos
+
1
;
else
if
(
pivot_pos
>
k
-
1
)
right
=
pivot_pos
-
1
;
else
return
a
[
pivot_pos
];
}
}
private
:
int
partition
(
vector
<
int
>&
a
,
int
left
,
int
right
)
{
srand
(
time
(
nullptr
));
//以当前时间为随机生成器的种子
int
pivotpos
=
rand
()%(
right
-
left
+
1
)
+
left
;
//产生【left,right】之间的数
swap
(
a
[
pivotpos
],
a
[
left
]);
//将枢轴暂时放入起始位置
int
pivot
=
left
;
//枢轴位置
while
(
left
<
right
)
{
//改造为从大到小partition,注意符号的变化
while
(
left
<
right
&&
a
[right] <= a[pivot
])
right
--;
//找到本次扫描中第一个不满足枢轴规律的高位数
while
(
left
<
right
&&
a
[
left
]
>=
a
[
pivot
])
left
++;
//找到本次扫描中第一个不满足枢轴规律的低位数
swap
(
a
[
left
],
a
[
right
]);
//交换以使满足枢轴规律
}
//最后结果是left和right均指向枢轴位置
swap
(
a
[
left
],
a
[
pivot
]);
//将枢轴移动到位
return
left
;
//返回枢轴位置
}
};
方法二：维护一个堆或者平衡二叉查找树存储这k个数
/*掌握
改进：维护一个大小为k的
小顶堆
，扫描输入数据，不断更新小顶堆的内容
最后堆顶元素即可n个数中第k大的数
leetcode耗时4ms
每次堆调整平均时间复杂度为O(logk)，共n次调整，故时间复杂度为O(nlogk)
O(nlogk), O(k)
*/
#include
#inlude
class
Solution
{
public
:
int
findKthLargest
(
vector
<
int
>&
a
,
int
k
)
{
if
(
a
.
empty
()
||
k
<=
0
||
k
>
a
.
size
())
return
0
;
//处理非法输入（可依题目返回适当值）
priority_queue
<
int
,
vector
<
int
>,
greater
<
int
>>
minheap
;
//构建小顶堆
for
(
int
i
=
0
;
i
<
a
.
size
();
i
++)
{
if
(
i
<=
k
-
1
)
minheap
.
push
(
a
[
i
]);
//将前k个元素插入容器
else
{
if
(
a[i] > minheap.top
())
//如果当前元素大于容器中最小的元素，则将该元素push进容器
{
minheap
.
pop
();
minheap
.
push
(
a
[
i
]);//每次堆调整复杂度为O（logk）
}
}
}
return
minheap
.
top
();
//返回堆顶元素,即为n个数中第k大的数（如果要返回前k个数，需将最后的minheap全部pop）
}
};
/*了解
用stl中make_heap函数，构建大顶堆，然后逐次输出堆顶元素
(原理与用priority_queue相同，不过没有额外空间)
用时11ms
O(nlogn + klogn)，O(1)
*/
#include
class
Solution
{
public
:
int
findKthLargest
(
vector
<
int
>&
nums
,
int
k
)
{
make_heap
(
nums
.
begin
(),
nums
.
end
());
//构建大顶堆，
用nums存储，与下面区别就是节省了空间
for
(
int
i
=
0
;
i
<
k
-
1
;
i
++)
{
pop_heap
(
nums
.
begin
(),
nums
.
end
());
//将堆顶元素移至末尾，重新调整使（begin~end-1）的元素满足堆规律
nums
.
pop_back
();
//移除末尾元素
}
return
nums
[
0
];
}
};
//用stl中sort函数，用时12ms
/*
#include
class Solution
{
public:
int findKthLargest(vector& nums, int k)
{
sort(nums.rbegin(), nums.rend()); //nums.rbegin()返回指向容器最后元素的逆向迭代器（因为sort默认按从小到大排序），
//sort将rbegin()指向位置当做第一个元素，故可以实现从大到小排序
return nums[k-1]; //第k个数，注意这里索引为k-1
}
};
*/
/*
//用stl中nth_element函数。?为什么没有sort()或者堆排序快
//用时14ms
#include
class Solution
{
public:
int findKthLargest(vector& nums, int k)
{
//nth_element(nums.begin(), nums.begin()+k-1, nums.end(),customMore);
nth_element(nums.begin(), nums.begin()+k-1, nums.end(),greater()); //原理为快排
//这里直接用STL里的函数，比较函数设置为greater(默认为小数在前)，注意中间(k-1)表示第k个最大的数
return nums[k-1]; //第k个数，注意这里索引为k-1
}
};
*/
/*
// 用自定义函数对象排序
struct
{
bool operator()(int a, int b) const
{
return a > b;
}
}customMore;
*/
相关：
Top K问题的两种解决思路
Top K问题在数据分析中非常普遍的一个问题（在面试中也经常被问到），比如：
从20亿个数字的文本中，找出最大的前100个。
解决Top K问题有两种思路，
-
最直观：小顶堆（大顶堆 -> 最小100个数）， 该方法没有修改输入数据，且非常适合海量数据的输入，不用一次性读入内存，可以借助硬盘一边读一边处理，平均时间复杂度为O(nlogk)。
-
较高效：基于partition函数的解法， 平均时间复杂度为O(n)，但是会修改输入数组。
Quick Select（用快排中的partition函数）的目标是找出第k大元素，所以
-
若切分后的左子数组的长度 > k，则第k大元素必出现在左子数组中；
-
若切分后的左子数组的长度 = k-1，则第k大元素为pivot；
-
若上述两个条件均不满足，则第k大元素必出现在右子数组中。
https://www.cnblogs.com/en-heng/p/6336625.html
quick select实质是分治法
分治法
，将1亿个数据分成100份，每份100万个数据，找到每份数据中最大的10000个，最后在剩下的100*10000个数据里面找出最大的10000个。如果100万数据选择足够理想，那么可以过滤掉1亿数据里面99%的数据。100万个数据里面查找最大的10000个数据的方法如下：用快速排序的方法，将数据分为2堆，如果大的那堆个数N大于10000个，继续对大堆快速排序一次分成2堆，如果大的那堆个数N大于10000个，继续对大堆快速排序一次分成2堆，如果大堆个数N小于10000个，就在小的那堆里面快速排序一次，找第10000-n大的数字；递归以上过程，就可以找到第1w大的数。参考上面的找出第1w大数字，就可以类似的方法找到前10000大数字了。此种方法需要每次的内存空间为10^6*4=4MB，一共需要101次这样的比较
https://blog.csdn.net/zyq522376829/article/details/47686867
posted @
2019-01-05 20:07 wikiwen 阅读(
...) 评论(
...) 编辑 收藏