web-dev-qa-db-fra.com

Pourquoi le type de bulle O (n ^ 2)?

for (int front = 1; front < intArray.length; front++)
{
    for (int i = 0; i  < intArray.length - front; i++)
    {
        if (intArray[i] > intArray[i + 1])
        {
            int temp = intArray[i];
            intArray[i] = intArray[i + 1];
            intArray[i + 1] = temp;
        }
    }
}

La boucle interne est itérative: n + (n-1) + (n-2) + (n-3) + ... + 1 fois.

La boucle externe est itérative: n fois.

Vous obtenez donc n * (la somme des nombres 1 à n)

N'est-ce pas n * (n * (n + 1)/2) = n * ((n ^ 2) + n/2)

Lequel serait (n ^ 3) + (n ^ 2)/2 = O (n ^ 3)?

Je suis certain que je fais ça mal. Pourquoi pas O (n ^ 3)?

algorithmsortingcomplexity-theorybig-obubble-sort
17
ordinary

Vous avez raison de dire que la boucle externe itère n fois et que la boucle interne itère également n fois, mais vous comptez deux fois le travail. Si vous comptez le travail total effectué en additionnant le travail effectué à chaque itération de la boucle de niveau supérieur, vous obtenez que la première itération fonctionne n, la seconde n - 1, la troisième n - 2, etc., puisque la ième l'itération de la boucle de niveau supérieur a la boucle intérieure faisant n - i travail.

Alternativement, vous pouvez compter le travail effectué en multipliant la quantité de travail effectuée par la boucle interne multipliée par le nombre total d'exécutions de cette boucle. La boucle interne fonctionne O(n) à chaque itération, et la boucle externe fonctionne pour O(n) itérations, donc le travail total est O ( n2).

Vous faites une erreur en essayant de combiner ces deux stratégies. Il est vrai que la boucle externe n fonctionne la première fois, puis n - 1, puis n - 2, etc. Cependant, vous ne multipliez pas ce travail par n pour obtenir le total. Cela compterait chaque fois n itérations. Au lieu de cela, vous pouvez simplement les additionner.

J'espère que cela t'aides!

22
templatetypedef

Votre boucle intérieure itère, EN TOTAL, comme vous l'avez dit n + (n-1) + (n-2) + (n-3) + ... + 1 fois. Il s'agit donc de O (n + (n-1) + (n-2) + (n-3) + ... + 1) = O (n (n + 1)/2) = O (n ^ 2)

6
GL770

La boucle interne itère n fois (dans le pire des cas):

for(int i = front; i < intArray.length; i++)

La boucle externe itère n fois:

for(int front = 0; front < intArray.length; front++)

Par conséquent O (n ^ 2)

1
NominSim

Comment vous calculez essentiellement N ...

  • Chaque ligne: +1

  • Chaque boucle * N

    Donc, vous commencez à ajouter des nombres à votre première boucle maintenant que vous avez N + 1, vous continuez et vous obtenez finalement N * N ou N ^ 2 pour le temps plus un certain nombre. Retirer le nombre car il est généralement insignifiant par rapport à N.

À peu près N est une représentation de tous les éléments de la boucle, comme 1,2,3 ... N. Il s'agit donc simplement de représenter un nombre et non le nombre de fois qu'une boucle, boucle.

1
Travis Pessetto
k=1(sigma k)n = n(n+1)/2
because:
  s = 1 +  2    + ... + (n-1) + n
  s = n + (n-1) + ... + 2     + 1
+)
===================================
  2s = n*(n+1)
   s = n(n+1)/2
in bubble sort, 
(n-1) + (n-2) + ... + 1 + 0 times compares 
which means, k=0(sigma k)n-1
, k=0(sigma k)n-1 equals [k=1(sigma k)n] - n
therefore, n(n+1)/2 - n = n(n-1)/2
which is 1/2(n^2-n) => O(1/2(n^2-n))
in big O notation, we remove constant, so
O(n^2-n)
n^2 is larger than n
O(n^2)
1
winuxguy

Ceci est une autre version pour accélérer le tri des bulles, lorsque nous utilisons juste une variable swapped pour terminer la première boucle for tôt. Vous pouvez gagner en complexité temporelle.

#include <stdio.h>
#include <stdbool.h>
#define MAX 10

int list[MAX] = {1,8,4,6,0,3,5,2,7,9};

void display(){
   int i;
   printf("[");

   for(i = 0; i < MAX; i++){
      printf("%d ",list[i]);
   }

   printf("]\n");
}

void bubbleSort() {
   int temp;
   int i,j;

   bool swapped = false;       

   // 1st loop
   for(i = 0; i < MAX-1; i++) { 
      swapped = false;

      // 2nd loop
      for(j = 0; j < MAX-1-i; j++) {
         printf("     Compare: [ %d, %d ] ", list[j],list[j+1]);

         if(list[j] > list[j+1]) {
            temp = list[j];
            list[j] = list[j+1];
            list[j+1] = temp;

            swapped = true;
         }

      }

      if(!swapped) {
         break;
      }

      printf("Loop number %d#: ",(i+1)); 
      display();                     
   }

}

main(){
   printf("Before: ");
   display();
   printf("\n");

   bubbleSort();
   printf("\nAfter: ");
   display();
}
0
Giang Nguyễn