Exemples d'algorithmes qui ont des complexités O (1), O (n log n) et O (log n)


114

Quels sont certains algorithmes que nous utilisons quotidiennement qui ont des complexités O (1), O (n log n) et O (log n)?


6
Pourquoi wiki? Ce n'est ni un sondage ni subjectif. Elle veut des exemples spécifiques des propriétés big-O.
paxdiablo

4
Wiki parce qu'il n'a pas de réponse correcte unique, il a plusieurs réponses.
Jason S

2
Wikipédia a également une bonne liste. en.wikipedia.org/wiki/Time_complexity
Homer6

Réponses:


234

Si vous voulez des exemples d'algorithmes / groupe d'énoncés avec une complexité temporelle comme indiqué dans la question, voici une petite liste -

O(1) temps

  • Accès à l'index de tableau (int a = ARR [5];)
  • Insertion d'un nœud dans la liste liée
  • Pousser et sauter sur la pile
  • Insertion et suppression de la file d'attente
  • Recherche du parent ou de l'enfant gauche / droit d'un nœud dans une arborescence stockée dans Array
  • Passer à l'élément suivant / précédent dans la liste doublement liée

O(n) temps

En un mot, tous les algorithmes de force brute, ou ceux de Noob qui nécessitent une linéarité, sont basés sur la complexité en temps O (n)

  • Traverser un tableau
  • Traverser une liste liée
  • Recherche linéaire
  • Suppression d'un élément spécifique dans une liste liée (non triée)
  • Comparaison de deux chaînes
  • Recherche de Palindrome
  • Counting / Bucket Sort et ici aussi vous pouvez trouver un million d'exemples de ce type ...

O(log n) temps

  • Recherche binaire
  • Trouver le plus grand / le plus petit nombre dans un arbre de recherche binaire
  • Certains algorithmes Divide and Conquer basés sur la fonctionnalité linéaire
  • Calcul des nombres de Fibonacci - Meilleure méthode Le principe de base ici n'est PAS d'utiliser les données complètes et de réduire la taille du problème à chaque itération

O(n log n) temps

Le facteur 'log n' est introduit en prenant en compte Divide and Conquer. Certains de ces algorithmes sont les mieux optimisés et fréquemment utilisés.

  • Tri par fusion
  • Tri de tas
  • Tri rapide
  • Certains algorithmes Divide and Conquer basés sur l'optimisation des algorithmes O (n ^ 2)

O(n^2) temps

Ces derniers sont censés être les algorithmes les moins efficaces si leurs homologues O (nlogn) sont présents. L'application générale peut être Brute Force ici.

  • Tri à bulles
  • Tri par insertion
  • Tri par sélection
  • Traverser un tableau 2D simple

5
Et n!? Je me suis demandé quel algorithme commun utilise n !?
Y_Y

Accéder à une valeur HashMap ainsi qu'à des algorithmes plus complexes comme une implémentation LRU qui atteignent O (1) en utilisant un HashMap et une liste à double lien ou en implémentant une pile avec la fonctionnalité PUSH / POP / MIN. L'implémentation récursive de Fibonacci relève également de N !.
ruralcoder

11
Mon OCD veut que vous basculiez la O(log n)liste avant la O(n)liste afin que la liste soit dans l'ordre du meilleur au pire. haha :)
Sam Eaton

4
Traverser un tableau 2D est en fait O (nxm) sauf s'il s'agit d'une matrice carrée.
Simon Peck

1
Le problème du «voyageur de commerce» est un exemple de n! (n factorial) aussi
Ju66ernaut

28

Un exemple simple de O(1)pourrait être return 23;- quelle que soit l'entrée, cela reviendra dans un temps fixe et fini.

Un exemple typique de O(N log N)serait le tri d'un tableau d'entrée avec un bon algorithme (par exemple, tri par fusion).

Un exemple typique O(log N)serait de rechercher une valeur dans un tableau d'entrée trié par bissection.


28

O (1) - la plupart des procédures de cuisson sont O (1), c'est-à-dire que cela prend un temps constant même s'il y a plus de gens pour cuisiner (dans une certaine mesure, car vous pourriez manquer d'espace dans votre casserole / vos casseroles et besoin de séparer la cuisson)

O (logn) - trouver quelque chose dans votre annuaire téléphonique. Pensez à la recherche binaire.

O (n) - lecture d'un livre, où n est le nombre de pages. C'est le temps minimum nécessaire pour lire un livre.

O (nlogn) - je ne peux pas penser immédiatement à quelque chose que l'on pourrait faire tous les jours qui est nlogn ... à moins que vous ne triiez les cartes en effectuant une fusion ou un tri rapide!


2
Il faut beaucoup plus de temps pour cuire un rôti qu'un mini-rôti :-)
paxdiablo

4
mais généralement, il faut le même temps pour cuire deux mini-rôtis et un mini-rôti, à condition que votre four soit assez grand pour le ranger!
Chii

1
Très perspicace! Je suppose que la tâche de compilation d'un téléphone ou d'un carnet d'adresses à partir d'une liste de noms / numéros pourrait être O (n log n)
squashed.bugaboo

10

Je peux vous proposer quelques algorithmes généraux ...

  • O (1): Accéder à un élément d'un tableau (ie int i = a [9])
  • O (n log n): tri rapide ou par fusion (en moyenne)
  • O (log n): recherche binaire

Ce seraient les réponses instinctives, car cela ressemble à une question de devoir / entretien. Si vous cherchez quelque chose de plus concret, c'est un peu plus difficile car le public en général n'aurait aucune idée de l'implémentation sous-jacente (Sparing open source bien sûr) d'une application populaire, et le concept en général ne s'applique pas à une "application"


4

O (1): trouver le meilleur coup suivant aux échecs (ou Go d'ailleurs). Comme le nombre d'états de jeu est fini, il n'y a que O (1) :-)


5
Oui, vous pouvez généralement échanger du temps contre de l'espace. Je l'ai fait pour un jeu tic-tac-toe car il n'y a que 3 ^ 9 états (moins si vous gérez les rotations intelligemment). Les échecs, cependant, ont un nombre d'états un peu plus grand :-)
paxdiablo

1
Le problème est que je ne vivrai que des O(1)nanosecondes, et vous savez sûrement ce qui O(1)se produira en premier ...
zardav

3

La complexité de l'application logicielle n'est pas mesurée et n'est pas écrite en notation big-O. Il n'est utile que de mesurer la complexité des algorithmes et de comparer des algorithmes dans le même domaine. Très probablement, quand nous disons O (n), nous voulons dire que c'est "O (n) comparaisons " ou "O (n) opérations arithmétiques". Cela signifie que vous ne pouvez comparer aucune paire d'algorithmes ou d'applications.


1
Ce n'est pas vraiment vrai. Si un algorithme a une complexité temporelle O (N), cela signifie que son exécution est limitée par k * N étapes pour une constante k. Il n'est pas vraiment important que les "étapes" soient des cycles CPU, des instructions d'assemblage ou des opérations (simples) en C. Ces détails sont masqués par la constante k.
Igor ostrovsky

Sans oublier que dans de nombreux cas pratiques, le "c" d'un algorithme O (logN) le rend pire qu'un algorithme O (N) plus simple.
Zed

Haha, oui, et par N, nous entendons alors la longueur d'entrée sur une bande de machine de Turing - ce qui fait que la forme verticale de division prend un temps exponentiel à mettre en œuvre. :-) Chaque domaine a ses propres exigences et son propre domaine d'abstraction.
P Shved

3

O (1) - Suppression d'un élément d'une liste doublement liée. par exemple

typedef struct _node {
    struct _node *next;
    struct _node *prev;
    int data;
} node;


void delete(node **head, node *to_delete)
{
    .
    .
    .
}

2

Vous pouvez ajouter les algorithmes suivants à votre liste:

O(1)- Déterminer si un nombre est pair ou impair; Travailler avec HashMap

O(logN) - calculer x ^ N,

O(N Log N) - Sous-séquence croissante la plus longue


1

O (n log n) est la borne supérieure de la vitesse à laquelle vous pouvez trier un ensemble arbitraire (en supposant un modèle de calcul standard et non hautement parallèle).


0

0 (logn) -Recherche binaire, élément de pic dans un tableau (il peut y avoir plus d'un pic) 0 (1) -en python calculant la longueur d'une liste ou d'une chaîne. La fonction len () prend 0 (1) temps. L'accès à un élément dans un tableau prend 0 (1) temps. L'opération de poussée dans une pile prend 0 (1) temps. 0 (nlogn) - Tri par fusion. le tri en python prend du temps nlogn. Ainsi, lorsque vous utilisez listname.sort (), cela prend du temps nlogn.

Remarque - La recherche dans une table de hachage prend parfois plus de temps constant en raison de collisions.


0

O (2 N )

O (2 N ) désigne un algorithme dont la croissance double à chaque ajout à l'ensemble de données d'entrée. La courbe de croissance d'une fonction O (2 N ) est exponentielle - commençant très peu profond, puis montant fulgurant. Un exemple de fonction O (2 N ) est le calcul récursif des nombres de Fibonacci:

int Fibonacci (int number)
{
if (number <= 1) return number;
return Fibonacci(number - 2) + Fibonacci(number - 1);
}

Tower of Hanoiaurait été un meilleur exemple.
Ashish Duklan
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.