Avaliando a complexidade do tempo médio de um dado algoritmo de bolhas.

11

Considerando esse pseudo-código de um conjunto de bolhas:

FOR i := 0 TO arraylength(list) STEP 1  
    switched := false
    FOR j := 0 TO arraylength(list)-(i+1) STEP 1
        IF list[j] > list[j + 1] THEN
            switch(list,j,j+1)
            switched := true
        ENDIF
    NEXT
    IF switched = false THEN
        break
    ENDIF
NEXT

Quais seriam as idéias básicas que eu teria em mente para avaliar a complexidade média de tempo? Já concluí o cálculo dos piores e melhores casos, mas estou decidido a avaliar como a complexidade média do loop interno, para formar a equação.

A pior equação de caso é:

\sum_{i = 0}^{n} (\sum_{j = 0}^{n - (i + 1)} O (1) + O (1)) = O (\frac{n^{2}}{2} + \frac{n}{2}) = O (n^{2})

$\sum_{i=0}^n \left(\sum_{j=0}^{n -(i+1)}O(1) + O(1)\right) = O(\frac{n^2}{2} + \frac{n}{2}) = O(n^2)$

em que o sigma interno representa o loop interno e o sigma externo representa o loop externo. Eu acho que preciso alterar os dois sigmas devido à cláusula "se-então-quebrar", que pode afetar o sigma externo, mas também devido à cláusula se no loop interno, que afetará as ações realizadas durante um loop (4 ações + 1 comparação, se verdadeira, ou apenas 1 comparação).

Para esclarecimentos sobre o termo tempo médio: esse algoritmo de classificação precisará de um tempo diferente em listas diferentes (do mesmo tamanho), pois o algoritmo pode precisar de mais ou menos etapas através dos / dentro dos loops até que a lista esteja completamente em ordem. Tento encontrar uma maneira matemática (não estatística) de avaliar a média das rodadas necessárias.

Por isso, espero que qualquer ordem tenha a mesma possibilidade.

— Sim
fonte

6

você primeiro precisa definir o que significa a média. Como o algoritmo é determinístico, você teria que assumir algum tipo de distribuição pelas entradas.

— Suresh

@ Sim Você pode mostrar como calculou a pior complexidade de tempo? Então, podemos ter uma idéia do que você quer dizer com complexidade média no seu caso.

— 0x0

Refiro-me ao tempo médio no tempo mais provável necessário (ou, em outras palavras, na versão matemática "pura" de: a média de todos os tempos observados na análise estatística). Por exemplo, quicksort tem uma média de nlogn, mesmo que o pior caso seja n ^ 2.

— Sim

1

@Sim No caso da bolha caso tipo média = pior caso complexidade de tempo, o que significa que, caso a complexidade média tempo é também

n^{2}

$n^2$

— 0x0

3

Há uma diferença. o quicksort é calculado como "sobre a escolha dos lançamentos de moedas ao escolher um pivô", o que não tem nada a ver com os dados. Considerando que você está sugerindo que deseja calcular a média "de todas as entradas", o que pressupõe (por exemplo) que você espera que cada ordem da entrada ocorra com a mesma probabilidade. isso é razoável, mas deve ser declarado explicitamente.

— Suresh

9

Para listas de comprimento , a média geralmente significa que você precisa começar com uma distribuição uniforme em todos os permutações de [ , .., ]: serão todas as listas que você deve considerar. $n$ $n!$ $1$ $n$

Sua complexidade média seria a soma do número de etapas de todas as listas divididas por . $n!$

$(x_i)_i$ $nd$ $d$ $x_i$ $i$ $\max_i(\max(1,i-x_i))$

Depois, faça as contas: para cada encontre o número de listas com essa distância máxima específica, então o valor esperado de é: $d$ $c_d$ $d$

\frac{1}{n!} \sum_{d = 0 0}^{n} d c_{d}

$\frac1{n!}\ \sum_{d=0}^n{\ dc_d}$

E esses são os pensamentos básicos, sem a parte mais difícil, que é encontrar . Talvez exista uma solução mais simples. $c_d$

EDIT: adicionado `esperado '

— jmad
fonte

Se você considera uma distribuição normal, existe uma maneira de aproximar o ?

c_{d}

$c_d$

— Sim

Você pode dizerporque você pode misturar em qualquer lugar todas as permutações de [ , .., ] e acrescentar no final, mas isso é pequeno para provar em média.

c_{d} \geq (n + 1 - d) (d - 1)!

$c_d≥(n+1-d)(d-1)!$

2

$2$

d

$d$

1

$1$

n ²

$n²$

— Jmad

19

Lembre-se de que um par (resp. ) é invertido se e . $(A[i], A[j])$ $(i,j)$ $i < j$ $A[i] > A[j]$

Supondo que seu algoritmo execute uma troca para cada inversão, o tempo de execução do seu algoritmo dependerá do número de inversões.

Calcular o número esperado de inversões em uma permutação aleatória uniforme é fácil:

Vamos ser uma permutação, e deixá- ser o inverso de . Por exemplo, se então . $P$ $R(P)$ $P$ $P = 2,1,3,4$ $R(P) = 4,3,1,2$

Para cada par de índices há uma inversão em exatamente um de ou . $(i,j)$ $P$ $R(P)$

Como o número total de pares é e o número total e cada par é invertido exatamente na metade das permutações, assumindo que todas as permutações sejam igualmente prováveis, o número esperado de inversões é: $n(n-1)/2$

\frac{n (n - 1)}{4}

$\frac{n(n-1)}{4}$

— Joe
fonte

isso avalia a quantidade de inversões. mas como sobre a quantidade de comparações que depende do tempo que o break-cláusula é interveio

— Sim

Você obtém uma comparação por troca e, o mais importante, uma troca pode reduzir o número de inversões em no máximo uma.

— Jmad

nem toda comparação resulta em uma troca, se a cláusula if for falsa, nenhuma inversão será feita.

— Sim

@rgrig Se você fornecer um contra-exemplo, corrigirei minha resposta.

— 21712 Joe

@ Joe: eu removi meu comentário. Estava errado.

— rgrig

2

Número de trocas <Número de iterações (no cenário otimizado e simples de caixa de bolhas)

Número de Inversões = Número de swaps.

Portanto, Número de iterações> $\frac{n(n-1)}{4}$

Portanto, a complexidade média dos casos é . Mas, como o caso médio não pode exceder o pior caso, obtemos que é , $\omega(n^2)$ $O(n^2)$

Isso nos dá: Tempo médio = $\theta(n^2)$

(Complexidade temporal = Número de iterações de iterações> número de swaps)

— kushj
fonte

0

neste documento, a complexidade do tempo médio da classificação de bolhas atingiu O (nlog (n))! http://algo.inria.fr/flajolet/Publications/ViFl90.pdf

— user84630
fonte

1

Isso não é verdade. Eles provam um resultado de Knuth mostrando que o número esperado de comparações é aproximadamente .

n^{2} / 2

$n^2/2$

— Yuval Filmus