Valutazione della complessità del tempo medio di un determinato algoritmo bolleort.

11

Considerando questo pseudo-codice di un bubblesort:

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

Quali sarebbero le idee di base che dovrei tenere a mente per valutare la complessità temporale media? Ho già compiuto il calcolo dei casi peggiori e migliori, ma sono bloccato a deliberare su come valutare la complessità media del ciclo interno, per formare l'equazione.

L'equazione del caso peggiore è:

\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)$

in cui il sigma interno rappresenta il ciclo interno e il sigma esterno rappresenta il ciclo esterno. Penso che dovrei cambiare entrambi i sigmi a causa della clausola "if-then-break", che potrebbe influenzare il sigma esterno ma anche a causa della clausola if nel ciclo interno, che influenzerà le azioni eseguite durante un ciclo (4 azioni + 1 confronto se vero, altrimenti solo 1 confronto).

Per chiarimenti sul termine tempo medio: questo algoritmo di ordinamento richiederà tempi diversi su elenchi diversi (della stessa lunghezza), poiché l'algoritmo potrebbe richiedere più o meno passaggi attraverso / all'interno dei loop fino a quando l'elenco è completamente in ordine. Cerco di trovare un modo matematico (non statistico) per valutare la media di quei round necessari.

Per questo mi aspetto che qualsiasi ordine abbia la stessa possibilità.

— Sim
fonte

6

devi prima definire cosa significa anche media. Poiché l'algoritmo è deterministico, dovresti assumere un qualche tipo di distribuzione sugli input.

— Suresh,

@Sim Puoi mostrare come hai calcolato la complessità temporale peggiore? Quindi, potremmo avere un'idea di cosa intendi per complessità media nel tuo caso.

— 0x0,

Intendo il tempo medio nel modo di tempo più probabile necessario (o in altre parole la versione matematica "pura" di: la media di tutti i tempi osservati facendo un'analisi statistica). Ad esempio quicksort ha una media di nlogn anche se il suo caso peggiore è n ^ 2.

— Sim

1

@Sim Nel caso di ordinamento a bolle caso medio = complessità nel caso peggiore, significato, caso medio La complessità temporale è anche

n^{2}

$n^2$

— 0x0

3

C'è una differenza quicksort è calcolato in media "sulla scelta dei lanci di monete quando si sceglie un perno" che non ha nulla a che fare con i dati. Considerando che si intende che si desidera eseguire la media "su tutti gli input", il che presuppone (ad esempio) che ci si aspetti che ogni ordinamento dell'input avvenga con la stessa probabilità. è ragionevole, ma dovrebbe essere dichiarato esplicitamente.

— Suresh,

9

Per gli elenchi di lunghezza , media di solito significa che devi iniziare con una distribuzione uniforme su tuttipermutazioni di [ , .., ]: saranno tutte le liste che devi considerare. $n$ $n!$ $1$ $n$

La complessità media sarebbe quindi la somma del numero di passaggi per tutti gli elenchi divisi per. $n!$

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

Quindi fai i calcoli: per ogni trova il numero delle liste con questa particolare distanza massima, quindi il valore atteso di è: $d$ $c_d$ $d$

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

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

E questi sono i pensieri di base senza la parte più difficile che sta trovando . Forse esiste una soluzione più semplice. $c_d$

EDIT: aggiunto `previsto '

— jmad
fonte

Se consideri una distribuzione normale, c'è un modo per approssimare ?

c_{d}

$c_d$

— Sim

Puoi direperché puoi mescolare ovunque tutte le permutazioni di [ , .., ] e aggiungere alla fine, ma è piccolo per dimostrare in media.

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

Ricorda che una coppia (resp. ) viene invertita se e . $(A[i], A[j])$ $(i,j)$ $i < j$ $A[i] > A[j]$

Supponendo che l'algoritmo esegua uno swap per ogni inversione, il tempo di esecuzione dell'algoritmo dipenderà dal numero di inversioni.

Calcolare il numero previsto di inversioni in una permutazione casuale uniforme è facile:

Lasciare sia una permutazione, e sia sia l'inverso di . Ad esempio, se allora . $P$ $R(P)$ $P$ $P = 2,1,3,4$ $R(P) = 4,3,1,2$

Per ogni coppia di indici c'è un'inversione esattamente in uno di o . $(i,j)$ $P$ $R(P)$

Poiché il numero totale di coppie è e il numero totale e ciascuna coppia sono invertiti esattamente nella metà delle permutazioni, supponendo che tutte le permutazioni siano ugualmente probabili, il numero previsto di inversioni è: $n(n-1)/2$

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

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

— Joe
fonte

questo valuta la quantità di inversioni. ma che dire della quantità di confronti che dipende dal momento in cui viene introdotta la clausola di break-

— sim

Si ottiene un confronto per swap e, soprattutto, uno swap può ridurre al massimo il numero di inversioni.

— jmad

non tutti i confronti si traducono in uno scambio, se la clausola if è falsa, non viene effettuata alcuna inversione.

— Sim

@rgrig Se fornisci un contro-esempio, correggerò la mia risposta.

— Joe

@Joe: ho rimosso il mio commento. Era sbagliato.

— Rgrig

2

Numero di swap <Numero di iterazioni (sia in casi ottimizzati che semplici)

Numero di inversioni = Numero di swap.

Pertanto, Numero di iterazioni> $\frac{n(n-1)}{4}$

Pertanto, la complessità media dei casi è . Ma poiché il caso medio non può superare il caso peggiore, si ottiene che è , $\omega(n^2)$ $O(n^2)$

Questo ci dà: Average Time = $\theta(n^2)$

(Complessità temporale = numero di iterazioni n. Di iterazioni> n. Di swap)

— kushj
fonte

0

in questo documento, la complessità temporale media dell'ordinamento delle bolle ha raggiunto O (nlog (n))! http://algo.inria.fr/flajolet/Publications/ViFl90.pdf

— user84630
fonte

1

Non è vero. Dimostrano un risultato di Knuth che mostra che il numero atteso di confronti è approssimativamente .

n^{2} / 2

$n^2/2$

— Yuval Filmus,