可能的重复: 滚动中值算法
假设整数是从数据流中读取的。以有效的方式查找到目前为止读取的元素的中位数。
我读过的解决方案:我们可以在左边使用max堆来表示小于有效中位数的元素，在右边使用min堆来表示大于有效中位数的元素。
在处理一个传入元素后，堆中的元素数量最多相差1个元素。当两个堆包含相同数量的元素时，我们发现堆根数据的平均值为有效中位数。当堆不平衡时，我们从包含更多元素的堆根中选择有效中值。
但是我们如何构造最大堆和最小堆也就是说，我们如何知道这里的有效中值?我认为我们应该在max-heap中插入1个元素然后在min-heap中插入下一个元素，如此类推。如果我说错了请指正。
当前回答
我可以确认@schmil-the-cat的答案是正确的。
下面是一个JS的实现。我不是算法专家，但我认为它可能对其他人有用。
class Heap {
constructor(isMin) {
this.heap = [];
this.isMin = isMin;
}
heapify() {
if (this.heap.length === 1) {
return;
}
let currentIndex = this.heap.length - 1;
while (true) {
if (currentIndex === 0) {
break;
}
const parentIndex = Math.floor((currentIndex - 1) / 2);
const parentValue = this.heap[parentIndex];
const currentValue = this.heap[currentIndex];
if (
(this.isMin && parentValue < currentValue) ||
(!this.isMin && parentValue > currentValue)
) {
break;
}
this.heap[parentIndex] = currentValue;
this.heap[currentIndex] = parentValue;
currentIndex = parentIndex;
}
}
insert(val) {
this.heap.push(val);
this.heapify();
}
pop() {
const val = this.heap.shift();
this.heapify();
return val;
}
top() {
return this.heap[0];
}
length() {
return this.heap.length;
}
}
function findMedian(arr) {
const topHeap = new Heap(true);
const bottomHeap = new Heap(false);
const output = [];
if (arr.length === 1) {
return arr[0];
}
topHeap.insert(Math.max(arr[0], arr[1]));
bottomHeap.insert(Math.min(arr[0], arr[1]));
for (let i = 0; i < arr.length; i++) {
const currentVal = arr[i];
if (i === 0) {
output.push(currentVal);
continue;
}
if (i > 1) {
if (currentVal < bottomHeap.top()) {
bottomHeap.insert(currentVal);
} else {
topHeap.insert(currentVal);
}
}
if (bottomHeap.length() - topHeap.length() > 1) {
const bottomVal = bottomHeap.pop();
topHeap.insert(bottomVal);
}
if (topHeap.length() - bottomHeap.length() > 1) {
const topVal = topHeap.pop();
bottomHeap.insert(topVal);
}
if (bottomHeap.length() === topHeap.length()) {
output.push(Math.floor((bottomHeap.top() + topHeap.top()) / 2));
continue;
}
if (bottomHeap.length() > topHeap.length()) {
output.push(bottomHeap.top());
} else {
output.push(topHeap.top());
}
}
return output;
}
其他回答
从流数据中找到运行中值有许多不同的解决方案，我将在答案的最后简要地讨论它们。
这个问题是关于特定解决方案(最大堆/最小堆解决方案)的细节，以及基于堆的解决方案如何工作的解释如下:
对于前两个元素，将较小的元素添加到左边的maxHeap中，将较大的元素添加到右边的minHeap中。然后逐个处理流数据，
Step 1: Add next item to one of the heaps
if next item is smaller than maxHeap root add it to maxHeap,
else add it to minHeap
Step 2: Balance the heaps (after this step heaps will be either balanced or
one of them will contain 1 more item)
if number of elements in one of the heaps is greater than the other by
more than 1, remove the root element from the one containing more elements and
add to the other one
然后在任何给定的时间，你都可以像这样计算中值:
If the heaps contain equal amount of elements;
median = (root of maxHeap + root of minHeap)/2
Else
median = root of the heap with more elements
Now I will talk about the problem in general as promised in the beginning of the answer. Finding running median from a stream of data is a tough problem, and finding an exact solution with memory constraints efficiently is probably impossible for the general case. On the other hand, if the data has some characteristics we can exploit, we can develop efficient specialized solutions. For example, if we know that the data is an integral type, then we can use counting sort, which can give you a constant memory constant time algorithm. Heap based solution is a more general solution because it can be used for other data types (doubles) as well. And finally, if the exact median is not required and an approximation is enough, you can just try to estimate a probability density function for the data and estimate median using that.
我发现的最有效的计算流百分位数的方法是P²算法:Raj Jain, Imrich Chlamtac:不存储观测数据的动态计算分位数和直方图的P²算法。Commun。Acm 28(10): 1076-1085 (1985)
该算法易于实现，工作效果非常好。然而，这只是一个估计，所以要记住这一点。来自摘要:
A heuristic algorithm is proposed for dynamic calculation qf the median and other quantiles. The estimates are produced dynamically as the observations are generated. The observations are not stored; therefore, the algorithm has a very small and fixed storage requirement regardless of the number of observations. This makes it ideal for implementing in a quantile chip that can be used in industrial controllers and recorders. The algorithm is further extended to histogram plotting. The accuracy of the algorithm is analyzed.
高效这个词取决于上下文。这个问题的解决方案取决于执行的查询量与插入量的关系。假设你插入N个数字K次直到最后你对中位数感兴趣。基于堆的算法的复杂度是O(N log N + K)。
考虑下面的替代方案。将数字放入一个数组中，对于每个查询，运行线性选择算法(比如使用快速排序枢轴)。现在你有了一个运行时间为O(K N)的算法。
现在如果K足够小(不频繁查询)，后一种算法实际上更有效，反之亦然。
一种直观的思考方法是如果你有一棵完全平衡的二叉搜索树，那么根就是中值元素，因为这里有相同数量的较大和较小的元素。 现在，如果树没有满，情况就不一样了，因为上一层中会有元素缺失。
所以我们可以用中值和两棵平衡二叉树，一棵表示小于中值的元素，另一棵表示大于中值的元素。这两棵树必须保持相同的大小。
当我们从数据流中获得一个新整数时，我们将其与中位数进行比较。如果它大于中值，我们就把它加到右边的树上。如果两个树的大小相差超过1，我们删除右边树的最小元素，使其成为新的中值，并将旧的中值放在左边树中。更小的也一样。
我可以确认@schmil-the-cat的答案是正确的。
下面是一个JS的实现。我不是算法专家，但我认为它可能对其他人有用。
class Heap {
constructor(isMin) {
this.heap = [];
this.isMin = isMin;
}
heapify() {
if (this.heap.length === 1) {
return;
}
let currentIndex = this.heap.length - 1;
while (true) {
if (currentIndex === 0) {
break;
}
const parentIndex = Math.floor((currentIndex - 1) / 2);
const parentValue = this.heap[parentIndex];
const currentValue = this.heap[currentIndex];
if (
(this.isMin && parentValue < currentValue) ||
(!this.isMin && parentValue > currentValue)
) {
break;
}
this.heap[parentIndex] = currentValue;
this.heap[currentIndex] = parentValue;
currentIndex = parentIndex;
}
}
insert(val) {
this.heap.push(val);
this.heapify();
}
pop() {
const val = this.heap.shift();
this.heapify();
return val;
}
top() {
return this.heap[0];
}
length() {
return this.heap.length;
}
}
function findMedian(arr) {
const topHeap = new Heap(true);
const bottomHeap = new Heap(false);
const output = [];
if (arr.length === 1) {
return arr[0];
}
topHeap.insert(Math.max(arr[0], arr[1]));
bottomHeap.insert(Math.min(arr[0], arr[1]));
for (let i = 0; i < arr.length; i++) {
const currentVal = arr[i];
if (i === 0) {
output.push(currentVal);
continue;
}
if (i > 1) {
if (currentVal < bottomHeap.top()) {
bottomHeap.insert(currentVal);
} else {
topHeap.insert(currentVal);
}
}
if (bottomHeap.length() - topHeap.length() > 1) {
const bottomVal = bottomHeap.pop();
topHeap.insert(bottomVal);
}
if (topHeap.length() - bottomHeap.length() > 1) {
const topVal = topHeap.pop();
bottomHeap.insert(topVal);
}
if (bottomHeap.length() === topHeap.length()) {
output.push(Math.floor((bottomHeap.top() + topHeap.top()) / 2));
continue;
}
if (bottomHeap.length() > topHeap.length()) {
output.push(bottomHeap.top());
} else {
output.push(topHeap.top());
}
}
return output;
}
