comment calculer la complexité temporelle du tri à bulles
J'essayais de comprendre la structure de données et différents algorithmes, puis je me suis trompé pour mesurer la complexité du temps de tri de Bubble.
for (c = 0; c < ( n - 1 ); c++) {
for (d = 0; d < n - c - 1; d++) {
if (array[d] > array[d+1]) /* For descending order use < */
{
swap = array[d];
array[d] = array[d+1];
array[d+1] = swap;
}
}
}
Maintenant, chaque Big O dit Meilleur cas O (n), Cas moyen (n2) et Meilleur cas (n2) .Mais quand je vois le code, trouvé dans la première phase de la boucle interne s'exécute n temps - 2 et ainsi de suite. Cela signifie que dans chaque itération, sa valeur diminue. Par exemple, si j'ai un [] = {4, 2, 9, 5, 3, 6, 11}, le nombre total de comparaisons sera donc -
1st Phase - 7 time
2nd phase - 6 time
3rd Phase - 5 time
4th Phase - 4 time
5th Phase - 3 time
6th Phase - 2 time
7th Phase - 1 time
donc, quand je calcule le temps, cela ressemble à = (7 + 6 + 5 + 4 + 3 + 2 + 1) + 7 = 35, mais la complexité temporelle la plus grave est n2, conformément à la doc.
alors quelqu'un peut me dire comment calculer la valeur correcte.
Passons en revue les cas pour Big O pour Bubble Sort
Cas 1) O(n) (Meilleur cas) Cette complexité temporelle peut survenir si le tableau est déjà trié, ce qui signifie qu'aucun échange n'a eu lieu et qu'une seule itération de n éléments
Cas 2) O (n ^ 2) (pire des cas) Le pire des cas est si le tableau est déjà trié mais dans l’ordre décroissant. Cela signifie que lors de la première itération, il faudrait examiner n éléments, puis après n-1 éléments (puisque le plus grand entier est à la fin) et ainsi de suite jusqu'à ce qu'une comparaison se produise . Big-O = n + n - 1 + n - 2 ... + 1 = (n * (n + 1))/2 = O (n ^ 2)
Dans votre exemple, il peut ne pas examiner ces nombreux éléments dans chaque phase car le tableau n'est pas dans l'ordre décroissant.
Vous avez donc remarqué que le nombre total de comparaisons effectuées est n + (n - 1) + ... + 2 + 1 . Cette somme est égale à n * (n + 1)/2 (voir Nombres triangulaires ) qui est égal à 0,5 n ^ 2 + 0,5 n qui est clairement O (n ^ 2).
il fait la comparaison entre deux éléments. so in 1ère phase - comparaison n-1. c'est-à-dire 6 2e phase - comparaison n-2. c’est-à-dire 5 .__ et ainsi de suite jusqu’à 1 ..__ et ainsi, sum = n (n-1)/2 c’est-à-dire O (n ^ 2).
s'il y a une erreur que vous pouvez corriger .....
O(n^2) = n(n-1)/2 est le bon.
Comme dans l'exemple ci-dessus de 5 éléments.
5(5-1)/2 == 10.
5(5+1)/2 != 10.
Expliquant pour le pire des cas ici:
elements = raw_input("enter comma separated elements : ")
elements = elements.split(',')
elements = map(int, elements)
length = len(elements)
for i in xrange(length - 1):
print "outer pass : ", i
for j in xrange(length - i - 1):
print "inner pass : ", j
if elements[j] > elements[j + 1]:
elements[j + 1], elements[j] = elements[j], elements[j + 1]
print "elements : ", elements
print elements
Sortie:
entrez des éléments séparés par des virgules: 5,4,3,2,1
passe extérieure: 0
passe intérieure: 0
éléments: [4, 5, 3, 2, 1]
passe intérieure: 1
éléments: [4, 3, 5, 2, 1]
passe intérieure: 2
éléments: [4, 3, 2, 5, 1]
passe intérieure: 3
éléments: [4, 3, 2, 1, 5]
passe extérieure: 1
passe intérieure: 0
éléments: [3, 4, 2, 1, 5]
passe intérieure: 1
éléments: [3, 2, 4, 1, 5]
passe intérieure: 2
éléments: [3, 2, 1, 4, 5]
passe extérieure: 2
passe intérieure: 0
éléments: [2, 3, 1, 4, 5]
passe intérieure: 1
éléments: [2, 1, 3, 4, 5]
passe extérieure: 3
passe intérieure: 0
éléments: [1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
Ainsi, à la première itération, tous les n éléments sont analysés, il analysera n - 1 éléments à la prochaine itération. Donc pour tous les éléments.
n + n - 1 + n - 2 ... + 1 = (n * (n + 1))/2 = O (n ^ 2)
Pour n nombre de nombres, le nombre total de comparaisons effectuées sera (n - 1) + ... + 2 + 1. Cette somme est égale à (n-1) * n/2 (voir Numéros triangulaires), ce qui correspond à 0,5 n ^ 2 - 0,5 n ie O (n ^ 2)