剑指offer 第 17 天
第 17 天
排序（中等）
剑指 Offer 40. 最小的k个数
输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。
示例 1：
输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]
示例 2：
输入：arr = [0,1,2,1], k = 1
输出：[0]
限制：
0 <= k <= arr.length <= 100000 <= arr[i] <= 10000
解题思路：直接排序、堆、二叉排序树、快速查找
直接排序：直接调用sort方法排序，输入前k个即可。显然不算一个好方法
class Solution {
public int[] getLeastNumbers(int[] arr, int k) {
int[] res = new int[k];
Arrays.sort(arr);
if (k >= 0) {
System.arraycopy(arr, 0, res, 0, k);
}
return res;
}
}
复杂度：时间 O(nlogn) 空间 O(logn)
堆：利用大根堆结构的性质，Java集合框架中已有 PriorityQueue 结构，建一个容量为 k 的堆，先添加 k 个数，然后每次弹出队列中最大的数，堆中保留的就是前 k 小的数
class Solution {
public int[] getLeastNumbers(int[] arr, int k) {
int[] res = new int[k];
if (k == 0) {
return res;
}
PriorityQueue<Integer> queue = new PriorityQueue<>((v1, v2) -> v2 - v1);
for (int i = 0; i < k; i ++) {
queue.add(arr[i]);
}
for (int i = k; i < arr.length; i ++) {
if (queue.peek() > arr[i]) {
queue.poll();
queue.add(arr[i]);
}
}
for (int i = 0; i < k; i ++) {
res[i] = queue.poll();
}
return res;
}
}
复杂度：时间 O(nlogk) 空间 O(k)
二叉排序树：利用 TreeMap 结构中元素的有序性，TreeMap的key 是数字，value 是该数字的个数。遍历数组中的数字，维护一个数字总个数为 K 的 TreeMap，而后与大根堆操作类似，先添加 K 个元素，然后每次比较新来数字与 TreeMap 中最大数字的大小，保证 TreeMap 中是最小的 K 个数
class Solution {
public int[] getLeastNumbers(int[] arr, int k) {
int[] res = new int[k];
if (k == 0) {
return res;
}
TreeMap<Integer, Integer> treeMap = new TreeMap<>();
for (int i = 0; i < k; i ++) {
treeMap.put(arr[i], treeMap.getOrDefault(arr[i], 0) + 1);
}
for (int i = k; i < arr.length; i ++) {
// k个中最大的元素及它的个数
Map.Entry<Integer, Integer> entry = treeMap.lastEntry();
if (entry.getKey() > arr[i]) {
treeMap.put(arr[i], treeMap.getOrDefault(arr[i], 0) + 1);
if (entry.getValue() == 1) {
treeMap.pollLastEntry();
}
else {
treeMap.put(entry.getKey(), entry.getValue() - 1);
}
}
}
int idx = 0;
for (Map.Entry<Integer, Integer> entry: treeMap.entrySet()) {
int temp = entry.getValue();
while (temp -- > 0) {
res[idx ++] = entry.getKey();
}
}
return res;
}
}
复杂度：时间 O(nlogk) 空间 O(k)
快速查找：直接通过快排思想切分排好第 K 小的数，那么它左边的数就是比它小的另外 K-1 个数，套用快排模板完成查找
class Solution {
public int[] getLeastNumbers(int[] arr, int k) {
if (k == 0 || arr.length == 0) {
return new int[0];
}
// 最后一个参数表示我们要找的是下标为k-1的数
return quickSearch(arr, 0, arr.length - 1, k - 1);
}
private int[] quickSearch(int[] nums, int lo, int hi, int k) {
// 每快排切分1次，找到排序后下标为j的元素，如果j恰好等于k就返回j以及j左边所有的数；
int j = partition(nums, lo, hi);
if (j == k) {
return Arrays.copyOf(nums, j + 1);
}
// 否则根据下标j与k的大小关系来决定继续切分左段还是右段。
return j > k? quickSearch(nums, lo, j - 1, k): quickSearch(nums, j + 1, hi, k);
}
// 快排切分，返回下标j，使得比nums[j]小的数都在j的左边，比nums[j]大的数都在j的右边。
private int partition(int[] nums, int lo, int hi) {
int v = nums[lo];
int i = lo, j = hi + 1;
while (true) {
while (++i <= hi && nums[i] < v);
while (--j >= lo && nums[j] > v);
if (i >= j) {
break;
}
int t = nums[j];
nums[j] = nums[i];
nums[i] = t;
}
nums[lo] = nums[j];
nums[j] = v;
return j;
}
}
复杂度：时间 O(n) 空间 O(logn)
剑指 Offer 41. 数据流中的中位数
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。
例如，
[2,3,4] 的中位数是 3
[2,3] 的中位数是 (2 + 3) / 2 = 2.5
设计一个支持以下两种操作的数据结构：
- void addNum(int num) - 从数据流中添加一个整数到数据结构中。
- double findMedian() - 返回目前所有元素的中位数。
示例 1：
输入：
["MedianFinder","addNum","addNum","findMedian","addNum","findMedian"]
[[],[1],[2],[],[3],[]]
输出：[null,null,null,1.50000,null,2.00000]
示例 2：
输入：
["MedianFinder","addNum","findMedian","addNum","findMedian"]
[[],[2],[],[3],[]]
输出：[null,null,2.00000,null,2.50000]
限制：
- 最多会对
addNum、findMedian进行50000次调用。
解题思路：数组排序（超时）、二分查找、双堆
双堆：利用一个大根堆和一个小根堆分别存放一半的元素，大根堆存放小元素，小根堆存放大元素，此时大根堆的堆顶与小根堆的堆顶刚好可以算出中位数
class MedianFinder {
PriorityQueue<Integer> smallHeap, bigHeap;
public MedianFinder () {
bigHeap = new PriorityQueue<>((n1, n2) -> n2-n1);
smallHeap = new PriorityQueue<>((n1, n2) -> n1-n2);
}
// 当元素为偶数数量时，两堆顶/2即为中间数
// 当元素为奇位数量时，选一个堆顶作为中间数存放（此题解选小顶堆）
public void addNum(int num) {
// (1)说明相差>1，调整平衡性。向smallHeap添加元素达到平衡
if (bigHeap.size() != smallHeap.size()) {
if (bigHeap.peek() > num) {
smallHeap.offer(bigHeap.poll());
bigHeap.offer(num);
}
else {
smallHeap.offer(num);
}
}
// (2)完全平衡(平衡性为0)时。选择一个堆作为中间数存放。这里选的是bigHeap，所以当平衡时优先往bigHeap存
else {
// 符合性质，直接push达到平衡性
if (bigHeap.isEmpty() || smallHeap.peek() > num) {
bigHeap.offer(num);
}
// 不符合性质，对调位置
else {
bigHeap.offer(smallHeap.poll());
smallHeap.offer(num);
}
}
}
public double findMedian() {
if (bigHeap.size() == smallHeap.size()) {
return ((double) bigHeap.peek() + smallHeap.peek()) / 2;
}
else {
return bigHeap.peek();
}
}
}
/**
* Your MedianFinder object will be instantiated and called as such:
* MedianFinder obj = new MedianFinder();
* obj.addNum(num);
* double param_2 = obj.findMedian();
*/
