Algoritmo não trivial para calcular uma mediana da janela deslizante

Preciso calcular a mediana em execução:

• Entrada: $n$ , $k$ , vetor .$(x_1, x_2, \dotsc, x_n)$

• Saída: vetor , em que é a mediana de .y i ( x i , x i + 1 , … , x i + k - 1$(y_1, y_2, \dotsc, y_{n-k+1})$$y_i$$(x_i, x_{i+1}, \dotsc, x_{i+k-1})$

(Sem trapacear com aproximações; eu gostaria de ter soluções exatas. Os elementos são números inteiros grandes.)$x_i$

Existe um algoritmo trivial que mantém uma árvore de pesquisa de tamanho ; o tempo total de execução é . (Aqui, uma "árvore de pesquisa" refere-se a alguma estrutura de dados eficiente que suporta inserções, exclusões e consultas medianas em tempo logarítmico.)O ( n log k $k$$O(n \log k)$

No entanto, isso me parece um pouco estúpido. Aprenderemos efetivamente todas as estatísticas de pedidos em todas as janelas de tamanho , não apenas nas medianas. Além disso, na prática, isso não é muito atraente, especialmente se for grande (grandes árvores de pesquisa tendem a ser lentas, a sobrecarga no consumo de memória não é trivial, a eficiência do cache geralmente é baixa etc.).$k$$k$

Podemos fazer algo substancialmente melhor?

Existem limites mais baixos (por exemplo, o algoritmo trivial é assintoticamente ideal para o modelo de comparação)?

Edit: David Eppstein deu um bom limite inferior para o modelo de comparação! Gostaria de saber se, no entanto, é possível fazer algo um pouco mais inteligente do que o algoritmo trivial?

Por exemplo, poderíamos fazer algo nesse sentido: dividir o vetor de entrada em partes do tamanho ; classifique cada parte (mantendo o controle das posições originais de cada elemento); e, em seguida, use o vetor classificado por partes para encontrar as medianas em execução de maneira eficiente sem nenhuma estrutura de dados auxiliar? É claro que isso ainda seria , mas, na prática, as matrizes de classificação tendem a ser muito mais rápidas do que manter as árvores de pesquisa.O ( n log k $k$$O(n \log k)$

Edit 2: Saeed queria ver algumas razões pelas quais eu acho que a classificação é mais rápida do que as operações da árvore de pesquisa. Aqui estão referências muito rápidas, para , : n = 10 $k = 10^7$$n = 10^8$

• ≈ 8s: classificando vetores com elementos cada$n/k$$k$
• ≈ 10s: classificando um vetor com elementos$n$
• Anos 80: inserções e exclusões em uma tabela de tamanho$n$$k$
• ≈ 390s: inserções e exclusões em uma árvore de pesquisa equilibrada de tamanho$n$$k$

A tabela de hash está lá apenas para comparação; não é de uso direto nesta aplicação.

Em resumo, temos quase uma diferença de fator 50 no desempenho da classificação versus operações equilibradas da árvore de pesquisa. E as coisas pioram se aumentarmos .$k$

(Detalhes técnicos: Dados = inteiros aleatórios de 32 bits. Computador = um laptop moderno típico. O código de teste foi escrito em C ++, usando as rotinas de biblioteca padrão (std :: sort) e estruturas de dados (std :: multiset, std :: Eu usei dois compiladores C ++ diferentes (GCC e Clang) e duas implementações diferentes da biblioteca padrão (libstdc ++ e libc ++). Tradicionalmente, std :: multiset era implementado como uma árvore vermelho-preta altamente otimizada.

Aqui está um limite inferior da classificação. Dado um conjunto de entrada de comprimento n a ser classificado, crie uma entrada para o seu problema mediano em execução que consiste em n - 1 cópias de um número menor que o mínimo de S , depois S em si e, em seguida, n - 1 cópias de um número maior que o máximo de S e defina k = $S$$n$$n-1$$S$$S$$n-1$$S$ . As medianas de execução deste entrada são o mesmo que a ordem de classificação de S .$k=2n-1$$S$

Assim, em um modelo de comparação de computação, é requerido tempo. Possivelmente, se suas entradas forem inteiras e você usar algoritmos de classificação inteira, poderá fazer melhor.$\Omega(n\log n)$

Edit: Este algoritmo agora é apresentado aqui: http://arxiv.org/abs/1406.1717

Sim, para resolver esse problema, é suficiente executar as seguintes operações:

• Classifique vetores, cada um com k elementos.$n/k$$k$
• Pós-processamento em tempo linear.

Muito grosso modo, a ideia é esta:

• Considere dois blocos adjacentes de entrada, e b , ambos com elementos k ; deixar os elementos ser um 1 , um 2 , . . . , Um k e$a$$b$$k$$a_1, a_2, ..., a_k$ na ordem de aparência no vetor de entrada$b_1, b_2, ..., b_k$$x$ .
• Classifique esses blocos e aprenda a classificação de cada elemento dentro do bloco.
• Aumentar os vectores de e b com ponteiros predecessor / sucessor de modo que, seguindo as cadeias ponteiro que pode atravessar os elementos em ordem crescente. Desta forma, temos construído duplamente listas ligadas a ' e b ' .$a$$b$$a'$$b'$
• Um por um, exclua todos os elementos da lista vinculada , na ordem inversa da aparência b $b'$ . Sempre que excluirmos um elemento,lembre-se de qual foi seu sucessor e predecessor no momento da exclusão.$b_k, b_{k-1}, ..., b_1$
• Agora manter "ponteiros medianos" e q que apontam para listas de um ' e b ' , respectivamente. Inicialize p no ponto médio de a ' e inicialize q no final da lista vazia b ' .$p$$q$$a'$$b'$$p$$a'$$q$$b'$

• Para cada :$i$

  • Exclua da lista a ' (é hora O ( 1 ) , apenas exclua da lista vinculada). Comparar um i com o elemento apontado por p para ver se excluído antes ou depois p .$a_i$$a'$$O(1)$$a_i$$p$$p$
  • Coloque volta à lista b ′ em sua posição original (este é o tempo O ( 1 ) , memorizamos o antecessor e sucessor de$b_i$$b'$$O(1)$$b_i$$b_i$$q$$q$ .
  • $p$$q$$a' \cup b'$$p$$q$$O(1)$$p$$q$$p$$q$

$k$

Aqui está um exemplo de implementação e benchmarks:

• https://github.com/suomela/median-filter

$n \approx 2\cdot 10^6$

• $O(n \log k)$ .
• $O(n \log k)$ , implementação em https://github.com/craffel/median-filter
• $O(n \log k)$ .
• $O(n k)$ .
• $\approx k/2$ ).
• Eixo Y = tempo de execução em segundos.
• Dados = números inteiros de 32 bits e números aleatórios de 64 bits, de várias distribuições.

$m$$O(n \log m + m \log n)$

$O(\log m)$$O(\log n)$$O(\log n)$ a cobrança ocorre apenas uma vez por mediana.

$O(n \log m + m \log k)$