最小的K个数
要求:时间复杂度:O(nlogk),空间复杂度:O(1)
方法1: 冒泡排序
时间复杂度:O(nk),空间复杂度:O(1)
原理: 利用冒泡排序一趟排序可以使一个元素归位的性质,排序K趟,即可得到最小的K个数。
function GetLeastNumbers_Solution(input, k) {
const res = [];
if (k > input.length) return input;
for (let i = 0; i < k; i++) {
for (let j = 0; j < input.length; j++) {
if (input[j] < input[j + 1]) {
[input[j], input[j + 1]] = [input[j + 1], input[j]];
}
}
res.push(input[input.length - i - 1]);
}
return res;
}
方法2: 堆排
时间复杂度:O(nlogk), 插入容量为k的大根堆时间复杂度为O(logk), 一共遍历n个元素
空间复杂度:O(k)
原理:建立一个容量为k的大根堆的优先队列。遍历一遍元素,如果队列大小 < k, 就直接入队,否则,让当前元素与队顶元素相比,如果队顶元素大,则出队,将当前元素入队。
function GetLeastNumbers_Solution(input, k) {
const queue = [],
res = [];
if (k === 0 || k > input.length) return res;
for (let i = 0; i < input.length; i++) {
if (queue.length < k) {
// 构建大顶堆
queue.push(input[i]);
buildMaxHeap(queue);
} else {
if (input[i] < queue[0]) {
queue.shift();
queue.push(input[i]);
buildMaxHeap(queue);
}
}
}
while (queue.length) {
res.push(queue[0]);
queue.shift();
}
// 用例需要
res.sort();
return res;
}
function buildMaxHeap(arr) {
// 从最底部开始
for (let i = Math.floor(arr.length / 2); i >= 0; i--) {
heapify(arr, i, arr.length);
}
}
// 调整的节点的下标i, arr无序的长度len
function heapify(arr, i, len) {
let left = 2 * i + 1;
let right = 2 * (i + 1);
let largest = i;
if (left < len && arr[left] > arr[largest]) {
largest = left;
}
if (right < len && arr[right] > arr[largest]) {
largest = right;
}
if (largest !== i) {
change(arr, i, largest);
heapify(arr, largest, len);
}
}
function change(arr, i, j) {
let temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
方法3: 快排思想
时间复杂度:平均时间复杂度为O(n), 每次partition的大小为n + n / 2 + n / 4 +… = 2n, 最坏时间复杂度为O(n ^ 2), 因为每次partition都只减少一个元素
空间复杂度:O(1)
原理: 对数组[l, r]一次快排partition过程可得到,[l, p), p, [p + 1, r) 三个区间, [l, p) 为小于等于p的值
[p + 1, r) 为大于等于p的值。
然后再判断p,利用二分法
1. 如果[l, p), p,也就是p + 1个元素(因为下标从0开始),如果p + 1 == k, 找到答案
2. 如果p + 1 < k, 说明答案在[p + 1, r) 区间内,
3. 如果p + 1 > k, 说明答案在[l, p) 内
function GetLeastNumbers_Solution(input, k) {
const res = [];
if (k === 0 || k > input.length) return res;
let l = 0, r = input.length;
while (l < r) {
let p = partition(input, l, r);
if (p + 1 === k) {
return input.slice(0, k);
}
if (p + 1 < k) {
l = p + 1;
} else {
r = p;
}
}
return res;
}
function partition(input, l, r) {
let pivot = input[r - 1];
let i = l;
for (let j = l; j < r - 1; ++j) {
if (input[j] < pivot) {
[input[i], input[j]] = [input[j], input[i]];
i++;
}
}
[input[i], input[r - 1]] = [input[r - 1], input[i]];
return i;
}
寻找第K大
利用最小的K个数的方法三和方法二的原理,利用堆和快排算法去处理。
// 快排分治+二分法
function findKth(a, n, K) {
let l = 0,
r = n;
let targetIndex = n - K;
while (l < r) {
let p = partition(a, l, r);
if (p === targetIndex) {
return a[targetIndex];
}
if (p < targetIndex) {
l = p + 1;
} else {
r = p;
}
}
}
数据流中的中位数
排序
排序之后计算中位数的方法不再赘述,可以参考几种排序方法实现。
在这介绍插入排序的方法
Insert()操作可改为插入排序
GetMedian()操作可直接从有序数组中获取中位数
时间复杂度:Insert()为O(n),即二分查找的O(logn)和挪动数据的O(n), GetMedian()为O(1)
空间复杂度:O(n)
堆
时间复杂度:Insert()为O(logn), GetMedian()为O(1)
空间复杂度:O(n)
中位数是指:有序数组中中间的那个数。则根据中位数可以把数组分为如下三段:
[0 … median - 1], [median], [median … arr.size() - 1],即[中位数的左边,中位数,中位数的右边]
那么,如果我有个数据结构保留[0…median-1]的数据,并且可以O(1)时间取出最大值,即arr[0…median-1]中的最大值
相对应的,如果我有个数据结构可以保留[median + 1 … arr.size() - 1] 的数据, 并且可以O(1)时间取出最小值,即
arr[median + 1 … arr.size() - 1] 中的最小值。
然后,我们把[median]即中位数,随便放到哪个都可以。
假设[0 … median - 1]的长度为l_len, [median + 1 … arr.sise() - 1]的长度为 r_len.
1.如果l_len == r_len + 1, 说明,中位数是左边数据结构的最大值
2.如果l_len + 1 == r_len, 说明,中位数是右边数据结构的最小值
3.如果l_len == r_len, 说明,中位数是左边数据结构的最大值与右边数据结构的最小值的平均值。
一个数据结构可以O(1)返回最小值的,其实就是小根堆,O(1)返回最大值的,其实就是大根堆。并且每次插入到堆中的时间复杂度为O(logn)
所以,GetMedian()操作算法过程为:
初始化一个大根堆,存中位数左边的数据,一个小根堆,存中位数右边的数据
动态维护两个数据结构的大小,即最多只相差一个。
const min_lq = [],
max_rq = [];
function Insert(num) {
// 加入左大顶堆
min_lq.push(num);
buildMaxHeap(min_lq);
// 分配到右小顶堆
max_rq.push(min_lq[0]);
buildMinHeap(max_rq);
min_lq.shift();
buildMaxHeap(min_lq);
if (min_lq.length < max_rq.length) {
min_lq.push(max_rq[0]);
buildMaxHeap(min_lq);
max_rq.shift();
buildMinHeap(max_rq);
}
}
function GetMedian() {
return min_lq.length > max_rq.length
? min_lq[0]
: parseFloat((min_lq[0] + max_rq[0]) / 2);
}
function buildMaxHeap(arr) {
// 从最底部开始
for (let i = Math.floor(arr.length / 2); i >= 0; i--) {
heapify(arr, i, arr.length);
}
}
// 调整的节点的下标i, arr无序的长度len
function heapify(arr, i, len) {
let left = 2 * i + 1;
let right = 2 * (i + 1);
let largest = i;
if (left < len && arr[left] > arr[largest]) {
largest = left;
}
if (right < len && arr[right] > arr[largest]) {
largest = right;
}
if (largest !== i) {
change(arr, i, largest);
heapify(arr, largest, len);
}
}
function change(arr, i, j) {
let temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
function buildMinHeap(arr) {
// 从最底部开始
for (let i = Math.floor(arr.length / 2); i >= 0; i--) {
heapifyMin(arr, i, arr.length);
}
}
function heapifyMin(arr, i, len) {
let left = 2 * i + 1;
let right = 2 * (i + 1);
let mini = i;
if (left < len && arr[left] < arr[mini]) {
mini = left;
}
if (right < len && arr[right] < arr[mini]) {
mini = right;
}
if (mini !== i) {
change(arr, i, mini);
heapifyMin(arr, mini, len);
}
}
module.exports = {
Insert: Insert,
GetMedian: GetMedian,
};