从整数流中查找运行中位数

可能重复：
C语言中的滚动中值算法

假定从数据流中读取整数。查找迄今为止有效读取的元素的中位数。

我已经读过的解决方案：我们可以在左侧使用最大堆表示小于有效中位数的元素，在右侧使用最小堆表示大于有效中位数的元素。

处理传入的元素后，堆中的元素数量最多相差1个元素。当两个堆包含相同数量的元素时，我们发现堆根数据的平均值为有效中位数。当堆不平衡时，我们从包含更多元素的堆根中选择有效中位数。

但是我们将如何构造最大堆和最小堆，即我们如何知道有效中位数？我认为我们将在max-heap中插入1个元素，然后在min-heap中插入下一个1个元素，以此类推。纠正我，如果我在这里错了。

从流数据中查找运行中位数有很多不同的解决方案，我将在答案的最后简要讨论它们。

问题是有关特定解决方案（最大堆/最小堆解决方案）的详细信息，下面说明基于堆的解决方案如何工作：

对于前两个元素，在左侧的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

现在，我将按照答案开头所承诺的一般性地讨论这个问题。从数据流中找到运行中位数是一个难题，对于一般情况而言，有效地找到具有内存限制的精确解决方案可能是不可能的。另一方面，如果数据具有我们可以利用的某些特征，那么我们可以开发有效的专业解决方案。例如，如果我们知道数据是整数类型，则可以使用计数排序，这可以为您提供恒定的内存恒定时间算法。基于堆的解决方案是一种更通用的解决方案，因为它也可以用于其他数据类型（双精度）。最后，如果不需要精确的中位数并且近似值足够，则可以尝试估计数据的概率密度函数，然后使用该函数估计中位数。

如果无法一次将所有项目保存在内存中，则此问题将变得更加棘手。堆解决方案要求您一次将所有元素保存在内存中。在此问题的大多数实际应用中，这是不可能的。

相反，当您看到数字时，请跟踪看到每个整数的次数计数。假设有4个字节的整数，即2 ^ 32个存储桶，或最多2 ^ 33个整数（每个int的键和计数），即2 ^ 35个字节或32GB。它可能远不止于此，因为您不需要存储键或为0的那些条目计数（即像python中的defaultdict一样）。这需要固定的时间来插入每个新的整数。

然后，在任何时候要找到中位数，只需使用计数即可确定哪个整数是中间元素。这需要恒定的时间（尽管常数很大，但是仍然是常数）。

如果输入的方差在统计上是分布的（例如，正态，对数正态等），则储层采样是一种从任意长的数字流中估计百分位数/中位数的合理方法。

int n = 0;  // Running count of elements observed so far  
#define SIZE 10000
int reservoir[SIZE];  

while(streamHasData())
{
  int x = readNumberFromStream();

  if (n < SIZE)
  {
       reservoir[n++] = x;
  }         
  else 
  {
      int p = random(++n); // Choose a random number 0 >= p < n
      if (p < SIZE)
      {
           reservoir[p] = x;
      }
  }
}

这样，“水库”便是所有输入的连续，均匀（公平）的样本-不论大小。因此，找到中位数（或任何百分位数）是对储层进行排序并轮询有趣点的直接方法。

由于存储库的大小是固定的，因此可以认为排序有效为O（1）-此方法的运行时间和内存消耗都是恒定的。

我发现的计算流的百分位数的最有效方法是P²算法：Raj Jain，Imrich Chlamtac：无需存储观测值即可动态计算量线和直方图的P²算法。公社 ACM 28（10）：1076-1085（1985）

该算法很容易实现，效果很好。但是，这是一个估计，因此请记住这一点。从摘要：

提出了一种启发式算法，用于中位数和其他分位数的动态计算。随着生成观察值，动态生成估算值。观测值不存储；因此，无论观察次数多少，该算法的存储需求都非常小且固定。这使其非常适合在可用于工业控制器和记录器的分位数芯片中实现。该算法进一步扩展到直方图绘图。分析了算法的准确性。

如果我们想找到最近看到的n个元素的中位数，则此问题有一个精确的解决方案，只需要n个要将最近见元素保留在内存中即可。它速度快，扩展性好。

的可转位skiplist支撑O（LN n）的插入，删除，和同时保持排序的顺序索引的搜索任意的元素。与跟踪第n个最旧条目的FIFO队列结合使用时，解决方案很简单：

class RunningMedian:
    'Fast running median with O(lg n) updates where n is the window size'

    def __init__(self, n, iterable):
        self.it = iter(iterable)
        self.queue = deque(islice(self.it, n))
        self.skiplist = IndexableSkiplist(n)
        for elem in self.queue:
            self.skiplist.insert(elem)

    def __iter__(self):
        queue = self.queue
        skiplist = self.skiplist
        midpoint = len(queue) // 2
        yield skiplist[midpoint]
        for newelem in self.it:
            oldelem = queue.popleft()
            skiplist.remove(oldelem)
            queue.append(newelem)
            skiplist.insert(newelem)
            yield skiplist[midpoint]

以下是完整工作代码的链接（一个易于理解的类版本和一个优化的生成器版本，内嵌可索引的跳过列表代码）：

• http://code.activestate.com/recipes/576930-ficient-running-median-using-an-indexable-skipli/

• http://code.activestate.com/recipes/577073。

考虑这一点的一种直观方法是，如果您有一个完全平衡的二叉搜索树，则根将是中值元素，因为会有相同数量的较小和较大元素。现在，如果树未满，情况就不会如此，因为最后一级将缺少元素。

因此，我们可以做的是拥有中位数，以及两棵平衡的二叉树，一棵表示小于中位数的元素，一棵表示大于中位数的元素。两棵树必须保持相同大小。

当我们从数据流中获得一个新的整数时，我们会将其与中位数进行比较。如果它大于中位数，则将其添加到正确的树中。如果两棵树的大小之差大于1，我们将删除右树的min元素，将其设为新的中位数，然后将旧的中值放入左树中。较小的情况类似。

高效是一个取决于上下文的词。该问题的解决方案取决于相对于插入量执行的查询量。假设您对中位数感兴趣的最后插入N个数字和K次。基于堆的算法的复杂度为O（N log N + K）。

考虑以下替代方案。将数字插入数组，然后为每个查询运行线性选择算法（例如，使用quicksort枢轴）。现在您有了运行时间为O（KN）的算法。

现在，如果K足够小（不频繁查询），则后一种算法实际上更有效，反之亦然。

您不能只用一个堆来做吗？更新：否。查看评论。

不变式：读取2*n输入后，最小堆将保留n最大的输入。

循环：读取2个输入。将它们都添加到堆中，并删除堆的分钟数。这将重新建立不变性。

因此，2n在读取输入后，堆的min为第n大。需要有一些额外的复杂性，才能对中间位置附近的两个元素求平均，并在输入数量奇数后处理查询。