web-dev-qa-db-fra.com

Big O - O(log(n)) exemple de code

Comme la notation Big O, "O (1)" peut décrire le code suivant:

O(1):

    for (int i = 0; i < 10; i++) {
        // do stuff 
        a[i] = INT;
    }

O(n):

    for (int i = 0; i < n; i++) {
        // do stuff 
        a[i] = INT;
    }

O(n^2):
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            // do stuff
            a[i][j] = INT;
        }
    }
  • Quel code peut O(log(n)) décrire?

Une autre question:

  • Quelles solutions existe-t-il pour les "problèmes Big O" (que faire lorsque l'on obtient beaucoup de données en entrée)?
javaalgorithmbig-o
21
Langkiller

Exemple classique:

while (x > 0) {  
   x/=2;  
}

Ce sera:

Iteration |   x
----------|--------
    0     |   x
    1     |  x/2
    2     |  x/4
   ...    |  ...
   ...    |  ...
    k     |  x/2^k

2k = x → Application de la bille des deux côtés → k = bûche (x)

38
Maroun

Pour O (logn), veuillez consulter tout code impliquant une stratégie de division et de conquête Exemple: Fusionner le tri et le tri rapide (le temps d'exécution prévu est O(nlogn) dans ces cas))

3
attaboy182

D'après la définition, log (n) (je veux dire ici log avec la base 2, mais la base n'a pas vraiment d'importance), est le nombre de fois que vous devez multiplier 2 par lui-même pour obtenir n. Ainsi, O(log(n)) exemple de code est:

i = 1
while(i < n)
    i = i * 2
    // maybe doing addition O(1) code

Dans des exemples de code réel, vous pouvez rencontrer O(log(n)) dans la recherche binaire, les arbres de recherche binaires équilibrés, de nombreux algorithmes récursifs, les files d'attente prioritaires.

3
pkacprzak

La recherche binaire est un exemple O (log (n)). http://en.wikipedia.org/wiki/Binary_search_algorithm .

1
vishnu viswanath

Dans le cas de la recherche binaire, vous essayez de trouver le nombre maximal d'itérations, et donc le nombre maximal de fois que l'espace de recherche peut être divisé en deux. Pour ce faire, divisez la taille de l'espace de recherche, n, par 2 à plusieurs reprises jusqu'à ce que vous arriviez à 1.

Donnons le nombre de fois que vous devez diviser n par 2 l'étiquette x. Étant donné que la division par 2, x fois équivaut à la division par 2 ^ x, vous finissez par devoir résoudre pour cette équation:

n/2 ^ x = 1, qui devient n = 2 ^ x,

Donc, en utilisant le logarithme, x = log (n), donc BIG - O de la recherche binaire est O (log (n))

Pour réitérer: x est le nombre de fois où vous pouvez diviser un espace de taille n en deux avant qu'il ne soit réduit à la taille 1.

http://www.quora.com/How-would-you-explain-O-log-n-in-algorithms-to-1st-year-undergrad-student

0
bsingh

Il convient de souligner que les algorithmes de complexité inférieure que vous avez décrits sont des sous-ensembles des algorithmes de complexité supérieure. En d'autres termes,

for (int i = 0; i < 10; i++) {
    // do stuff 
    a[i] = INT;
}

est en O (1), mais aussi en O (n), O (n²), et, si vous vouliez être intelligent, O (log (n)) Pourquoi? Parce que tous les algorithmes à temps constant sont limités par certaines fonctions linéaires, quadratiques, etc.

Quelles solutions existe-t-il pour les "problèmes Big O" (que faire lorsque l'on obtient beaucoup de données en entrée)?

Cette question n'a pas beaucoup de sens pour moi. "Beaucoup de données" est tout à fait arbitraire. N'oubliez pas que Big O n'est pas la seule mesure de la complexité temporelle; en plus de mesurer la complexité temporelle du pire des cas, nous pouvons également examiner le meilleur cas et le cas moyen, bien que ceux-ci puissent être un peu plus difficiles à calculer.

0
lealand