Evaluar la complejidad del tiempo promedio de un algoritmo de bubbleort dado.

11

Considerando este pseudocódigo de un bubbleort:

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

¿Cuáles serían las ideas básicas que tendría que tener en cuenta para evaluar la complejidad temporal promedio? Ya logré calcular el peor y el mejor de los casos, pero estoy atascado deliberando cómo evaluar la complejidad promedio del ciclo interno, para formar la ecuación.

La peor ecuación del caso es:

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

en el que el sigma interno representa el bucle interno, y el sigma externo representa el bucle externo. Creo que necesito cambiar ambas sigmas debido a la cláusula "if-then-break", que podría afectar la sigma externa pero también debido a la cláusula if en el bucle interno, que afectará las acciones realizadas durante un bucle (4 acciones + 1 comparación si es verdadera, de lo contrario solo 1 comparación).

Para aclarar el término tiempo promedio: este algoritmo de clasificación necesitará un tiempo diferente en diferentes listas (de la misma longitud), ya que el algoritmo podría necesitar más o menos pasos a través / dentro de los bucles hasta que la lista esté completamente en orden. Trato de encontrar una forma matemática (no estadística) de evaluar el promedio de esas rondas necesarias.

Para esto espero que cualquier orden sea de la misma posibilidad.

algorithms time-complexity sorting average-case Sim
fuente

66

primero debe definir qué significa incluso el promedio. Dado que el algoritmo es determinista, tendría que asumir algún tipo de distribución sobre las entradas.

Suresh

@Sim ¿Puede mostrar cómo calculó la peor complejidad de tiempo? Entonces, podríamos tener una idea de lo que quiere decir con complejidad promedio en su caso.

0x0

Me refiero al tiempo promedio en la forma del tiempo más probable necesario (o en otras palabras, la versión matemática "pura" de: la media de todos los tiempos observados haciendo un análisis estadístico). Por ejemplo, quicksort tiene un promedio de nlogn a pesar de que su peor caso es n ^ 2.

Sim

1

@Sim En el caso de la clasificación de burbujas, caso promedio = complejidad del tiempo en el peor de los casos, es decir, la complejidad del tiempo del caso promedio también es

n^{2}

$n^2$

0x0

3

Hay una diferencia quicksort se promedia "sobre la elección de lanzar monedas al elegir un pivote" que no tiene nada que ver con los datos. Mientras que está insinuando que desea promediar "sobre todas las entradas", lo que supone (por ejemplo) que espera que cada pedido de la entrada ocurra con la misma probabilidad. eso es razonable, pero debe declararse explícitamente.

Suresh

9

Para las listas de longitud , el promedio generalmente significa que debe comenzar con una distribución uniforme en todas las permutaciones de [ , .., ]: esas serán todas las listas que debe tener en cuenta. $n$ $n!$ $1$ $n$

¡Su complejidad promedio sería la suma del número de pasos para todas las listas divididas por . $n!$

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

Luego haces los cálculos: para cada encuentra el número de listas con esta distancia máxima particular, entonces el valor esperado de es: $d$ $c_d$ $d$

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

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

Y esos son los pensamientos básicos sin la parte más difícil que es encontrar . Quizás haya una solución más simple. $c_d$

EDITAR: agregado `esperado '

jmad
fuente

Si considera una distribución normal, ¿hay alguna manera de aproximar ?

c_{d}

$c_d$

Sim

¡Puedes decirporque puedes mezclar en cualquier lugar todas las permutaciones de [ , .., ] y agregar al final, pero eso es pequeño para probar en promedio.

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

Recuerde que un par (resp. ) se invierte si y . $(A[i], A[j])$ $(i,j)$ $i < j$ $A[i] > A[j]$

Suponiendo que su algoritmo realice un intercambio por cada inversión, el tiempo de ejecución de su algoritmo dependerá de la cantidad de inversiones.

Calcular el número esperado de inversiones en una permutación aleatoria uniforme es fácil:

Deje que sea una permutación, y dejar que sea el inverso de . Por ejemplo, si entonces . $P$ $R(P)$ $P$ $P = 2,1,3,4$ $R(P) = 4,3,1,2$

Para cada par de índices hay una inversión en exactamente uno de o . $(i,j)$ $P$ $R(P)$

Como el número total de pares es , y el número total y cada par se invierte exactamente en la mitad de las permutaciones, suponiendo que todas las permutaciones sean igualmente probables, el número esperado de inversiones es: $n(n-1)/2$

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

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

Joe
fuente

Esto evalúa la cantidad de inversiones. pero ¿qué hay de la cantidad de comparaciones que depende del momento en que se introduce la cláusula de ruptura

Sim

Obtiene una comparación por intercambio y, lo que es más importante, un intercambio puede reducir el número de inversiones a lo sumo.

jmad

no todas las comparaciones resultan en un intercambio, si la cláusula if es falsa, no se realiza ninguna inversión.

Sim

@rgrig Si proporciona un contraejemplo, corregiré mi respuesta.

Joe

@ Joe: eliminé mi comentario. Estaba mal.

rgrig

2

Número de intercambios <Número de iteraciones (tanto en el caso de burbuja optimizado como en el simple)

Número de inversiones = Número de intercambios.

Por lo tanto, Número de iteraciones> $\frac{n(n-1)}{4}$

Por lo tanto, la complejidad del caso promedio es . Pero, dado que el caso promedio no puede exceder el peor de los casos, obtenemos que es , $\omega(n^2)$ $O(n^2)$

Esto nos da: Tiempo promedio = $\theta(n^2)$

(Complejidad de tiempo = Número de iteraciones no. De iteraciones> no. De swaps)

kushj
fuente

0

en este documento, la complejidad del tiempo promedio de clasificación de burbujas alcanzó O (nlog (n))! http://algo.inria.fr/flajolet/Publications/ViFl90.pdf

usuario84630
fuente

1

Eso no es cierto. Demuestran un resultado de Knuth que muestra que el número esperado de comparaciones es aproximadamente .

n^{2} / 2

$n^2/2$

Yuval Filmus

Evaluar la complejidad del tiempo promedio de un algoritmo de bubbleort dado.

Respuestas: