Évaluation de la complexité temporelle moyenne d'un algorithme deort de bulles donné.

11

Considérant ce pseudo-code d'une bulle:

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

Quelles seraient les idées de base que je devrais garder à l'esprit pour évaluer la complexité temporelle moyenne? J'ai déjà accompli le calcul des pires et des meilleurs cas, mais je suis coincé à réfléchir à la façon d'évaluer la complexité moyenne de la boucle interne, pour former l'équation.

L'équation du pire cas est:

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

dans lequel le sigma intérieur représente la boucle intérieure, et le sigma extérieur représente la boucle extérieure. Je pense que je dois changer les deux sigmas en raison de la clause "if-then-break", qui pourrait affecter le sigma externe mais aussi en raison de la clause if dans la boucle interne, qui affectera les actions effectuées pendant une boucle (4 actions + 1 comparaison si vrai, sinon juste 1 comparaison).

Pour des éclaircissements sur le terme temps moyen: cet algorithme de tri aura besoin de temps différent sur différentes listes (de même longueur), car l'algorithme peut avoir besoin de plus ou moins d'étapes dans / dans les boucles jusqu'à ce que la liste soit complètement en ordre. J'essaie de trouver une méthode mathématique (non statistique) pour évaluer la moyenne de ces rondes nécessaires.

Pour cela, je m'attends à ce que toute commande soit de la même possibilité.

— Sim
source

6

vous devez d'abord définir ce que signifie moyenne. Puisque l'algorithme est déterministe, vous devez supposer une sorte de distribution sur les entrées.

— Suresh

@Sim Pouvez-vous montrer comment vous avez calculé la complexité temporelle la plus défavorable? Ensuite, nous pourrions avoir une idée de ce que vous entendez par complexité moyenne dans votre cas.

— 0x0

Je veux dire le temps moyen dans le sens du temps le plus probable nécessaire (ou en d'autres termes la version mathématique «pure» de: la moyenne de tous les temps observés faisant une analyse statistique). Par exemple, quicksort a une moyenne de nlogn même si son pire cas est n ^ 2.

— Sim

1

@Sim Dans le cas du tri moyen des bulles, cas moyen = pire complexité du temps, ce qui signifie que la complexité moyenne du temps est également

n^{2}

$n^2$

— 0x0

3

Il y a une différence. quicksort est en moyenne "sur le choix des lancers de pièces lors du choix d'un pivot" qui n'a rien à voir avec les données. Alors que vous sous-entendez que vous voulez faire la moyenne "sur toutes les entrées", ce qui suppose (par exemple) que vous vous attendez à ce que chaque ordre de l'entrée se produise avec la même probabilité. c'est raisonnable, mais cela devrait être indiqué explicitement.

— Suresh

9

$n$ $n!$ $1$ $n$

$n!$

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

Ensuite, vous faites le calcul: pour chaque trouvez le nombre de listes avec cette distance maximale particulière, alors la valeur attendue de est: $d$ $c_d$ $d$

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

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

Et ce sont les pensées de base sans la partie la plus difficile qui trouve . Il existe peut-être une solution plus simple. $c_d$

EDIT: ajouté «attendu»

— jmad
source

Si vous considérez une distribution normale, existe-t-il un moyen d'approximer ?

c_{d}

$c_d$

— Sim

Vous pouvez direcar vous pouvez mêler n'importe où toutes les permutations de [ , .., ] et ajouter à la fin mais c'est petit pour prouver en moyenne.

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

Rappelons qu'une paire (resp. ) est inversée si et . $(A[i], A[j])$ $(i,j)$ $i < j$ $A[i] > A[j]$

En supposant que votre algorithme effectue un swap pour chaque inversion, le temps d'exécution de votre algorithme dépendra du nombre d'inversions.

Le calcul du nombre attendu d'inversions dans une permutation aléatoire uniforme est facile:

Laissez une permutation, et que soit l'inverse de . Par exemple, si alors . $P$ $R(P)$ $P$ $P = 2,1,3,4$ $R(P) = 4,3,1,2$

Pour chaque paire d'indices il y a une inversion dans exactement l'un de ou . $(i,j)$ $P$ $R(P)$

Étant donné que le nombre total de paires est , et que le nombre total et chaque paire sont inversés dans exactement la moitié des permutations, en supposant que toutes les permutations sont également probables, le nombre attendu d'inversions est: $n(n-1)/2$

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

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

— Joe
source

cela évalue la quantité d'inversions. mais que diriez-vous du nombre de comparaisons qui dépend du moment où la pause est introduite

— Sim

Vous obtenez une comparaison par échange et, surtout, un échange peut réduire le nombre d'inversions d'au plus un.

— jmad

toutes les comparaisons n'entraînent pas un échange, si la clause if est fausse, aucune inversion n'est effectuée.

— Sim

@rgrig Si vous fournissez un contre-exemple, je corrigerai ma réponse.

— Joe

@Joe: J'ai supprimé mon commentaire. C'était faux.

— rgrig

2

Nombre de swaps <nombre d'itérations (dans les deux scénarios optimisé et simple bulle)

Nombre d'inversions = nombre de swaps.

Par conséquent, nombre d'itérations> $\frac{n(n-1)}{4}$

Ainsi, la complexité moyenne des cas est . Mais, comme le cas moyen ne peut pas dépasser le pire des cas, nous obtenons que c'est , $\omega(n^2)$ $O(n^2)$

Cela nous donne: Temps moyen = $\theta(n^2)$

(Complexité temporelle = nombre d'itérations nbre d'itérations> nbre de swaps)

— kushj
source

0

dans ce document, la complexité temporelle moyenne du tri à bulles a atteint O (nlog (n))! http://algo.inria.fr/flajolet/Publications/ViFl90.pdf

— user84630
source

1

Ce n'est pas vrai. Ils prouvent un résultat de Knuth montrant que le nombre attendu de comparaisons est à peu près .

n^{2} / 2

$n^2/2$

— Yuval Filmus