Знайти запущену медіану з потоку цілих чисел

Можливий дублікат:
середній алгоритм прокатки в С

Враховуючи, що цілі числа читаються з потоку даних. Знайдіть медіану елементів, прочитаних на сьогодні, ефективно.

Прочитане нами рішення: Ми можемо використовувати максимальну купу на лівій стороні для представлення елементів, менших за ефективну медіану, і міні-купу на правій стороні, щоб представити елементи, що перевищують ефективну медіану.

Після обробки вхідного елемента кількість елементів у купи відрізняється щонайменше на 1 елемент. Коли обидва купи містять однакову кількість елементів, ми знаходимо середнє значення кореневих даних купи як ефективну медіану. Коли купи не збалансовані, ми вибираємо ефективну серединку з кореня купи, що містить більше елементів.

Але як би ми побудували максимальну купу і міні-купу, тобто як ми могли б знати ефективну медіану тут? Я думаю, що ми б вставили 1 елемент у max-heap, а потім наступний 1 елемент у min-heap і так далі для всіх елементів. Виправте мене, якщо я тут помиляюся.

Існує ряд різних рішень для пошуку медіани із потокових даних, я коротко розповім про них у самому кінці відповіді.

Питання стосується деталей конкретного рішення (макс. Хеп / хв. Хеп-розчин), а також того, як працює розчин на основі купи, пояснюється нижче:

Для перших двох елементів додайте менший до 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). Це потрібно постійний час для вставки кожного нового цілого числа.

Тоді в будь-якій точці, щоб знайти медіану, просто використовуйте підрахунки, щоб визначити, яке ціле число є середнім елементом. Це займає постійний час (хоч і велика константа, але все-таки константа).

Якщо дисперсія вхідних даних є статистично розподіленою (наприклад, нормальною, нормальною та нормальною тощо), то вибірка резервуарів є розумним способом оцінки відсотків / медіанів з довільно довгого потоку чисел.

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²: Радж Джайн, Імріх Хламтак: Алгоритм P² для динамічного обчислення квантолів та гістограм без збереження спостережень. Комун. ACM 28 (10): 1076-1085 (1985)

Алгоритм прямо реалізований та працює надзвичайно добре. Це, однак, оцінка, тому майте це на увазі. З реферату:

Запропоновано евристичний алгоритм для динамічного обчислення qf медіани та інших квантилів. Оцінки виробляються динамічно в міру формування спостережень. Спостереження не зберігаються; отже, алгоритм має дуже малу та фіксовану вимогу зберігання незалежно від кількості спостережень. Це робить його ідеальним для впровадження в кількісний чіп, який можна використовувати в промислових контролерах та рекордерах. Алгоритм далі поширюється на побудову гістограми. Проаналізовано точність алгоритму.

Якщо ми хочемо знайти медіану n останніх побачених елементів, ця проблема має точне рішення, яке потребує лише n останніх побачених елементів, щоб зберігати їх у пам'яті. Це швидко і добре масштабує.

An індексовані skiplist опори О (пер п) вставка, видалення і індексований пошук довільних елементів, зберігаючи при цьому порядок сортування. У поєднанні з чергою FIFO, яка відстежує n-ту найдавнішу запис, рішення просте:

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-efficient-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дані були прочитані, мінус купи - п’ятий за величиною. Потрібно мати трохи додаткових ускладнень, щоб оцінити два елементи навколо медіанної позиції та обробити запити після непарної кількості входів.