Exemples d'algorithmes comportant des complexités O (1), O (n log n) et O (log n)
Quels sont les algorithmes que nous utilisons quotidiennement qui ont des complexités O (1), O (n log n) et O (log n)?
Si vous voulez des exemples d’algorithmes/de groupes d’énoncés avec la complexité temporelle donnés dans la question, voici une petite liste -
O (1) fois
1. Accès à un tableau (int a = ARR [5];)
2. Insertion d'un nœud dans la liste liée
3. Pousser et sauter sur la pile
4. Insertion et retrait de la file d'attente
5. Connaître le parent ou l'enfant gauche/droit d'un nœud dans une arborescence stockée dans Array
6. Passer à l'élément suivant/précédent de la liste doublement chaînée
et vous pouvez trouver un million d'autres exemples ...
À temps
1. Traverser un tableau
2. Parcourir une liste chaînée
3. Recherche linéaire
4. Suppression d'un élément spécifique dans une liste liée (non trié)
5. Comparer deux chaînes
6. Vérification du palindrome
7. Compter/Trier par seau
Et ici aussi, vous pouvez trouver un million d'autres exemples ...
En résumé, tous les algorithmes de Brute Force, ou ceux de Noob nécessitant une linéarité, sont basés sur la complexité temporelle de O(n)
Temps O (log n)
1. Recherche binaire
2. Trouver le plus grand/le plus petit nombre dans un arbre de recherche binaire
3. Certains algorithmes de division et de conquête basés sur la fonctionnalité linéaire
4. 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
Temps O (nlogn)
1. Tri par fusion
2. Sorte de tas
3. Tri rapide
4. Certains algorithmes de division et de conquête basés sur l'optimisation d'algorithmes O (n ^ 2)
Le facteur de 'log n' est introduit en prenant en compte Divide and Conquer. Certains de ces algorithmes sont les meilleurs optimisés et utilisés fréquemment.
O (n ^ 2) fois
1. Tri à bulles
2. Tri par insertion
3. Tri de sélection
4. Traverser un tableau 2D simple
Ceux-ci sont supposés être les algorithmes les moins efficaces si leurs contreparties O(nlogn) sont présents L'application générale peut être Brute Force ici.
J'espère que cela répond bien à votre question. Si les utilisateurs ont plus d'exemples à ajouter, je serai plus qu'heureux :)
Un exemple simple de O(1) pourrait être return 23; - quelle que soit l'entrée, elle sera renvoyée dans un temps fixe et fini.
Un exemple typique de O(N log N) serait de trier un tableau d’entrée avec un bon algorithme (par exemple, mergesort).
Un exemple typique si O(log N) rechercherait une valeur dans un tableau d'entrée trié par bissection.
O(1) - most cooking procedures are O(1), that is, it takes a constant amount of time even if there are more people to cook for (to a degree, because you could run out of space in your pot/pans and need to split up the cooking)
O (logn) - trouver quelque chose dans votre annuaire téléphonique. Pensez recherche binaire.
O (n) - lecture d'un livre, où n est le nombre de pages. C'est le temps minimum qu'il faut pour lire un livre.
O (nlogn) - Je ne peux pas penser immédiatement à quelque chose que l'on pourrait faire tous les jours et qui est nlogn ... à moins de trier les cartes par fusion ou tri rapide!
Je peux vous proposer des algorithmes généraux ...
- O(1): Accessing an element in an array (i.e. int i = a[9])
- O(n log n): quick or mergesort (On average)
- O (log n): recherche binaire
Celles-ci seraient les réponses instinctives car cela ressemble à une question de type devoirs/entretien. Si vous recherchez 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) d'une application populaire, et le concept en général ne s'applique pas à une "application"
O (1) - Suppression d'un élément d'une liste doublement chaînée. par exemple.
typedef struct _node {
struct _node *next;
struct _node *prev;
int data;
} node;
void delete(node **head, node *to_delete)
{
.
.
.
}
Vous pouvez ajouter les algorithmes suivants à votre liste:
O(1) - Déterminer si un nombre est pair ou impair; Travailler avec HashMap
O(logN) - informatique x ^ N,
O(N Log N) - La plus longue sous-séquence croissante
La complexité de l'application logicielle n'est pas mesurée et n'est pas écrite en notation big-O. Il est seulement utile de mesurer la complexité des algorithmes et de comparer des algorithmes dans le même domaine. Très probablement, lorsque nous disons O (n), nous entendons par "opérations arithmétiques O (n) comparaisons" Cela signifie que vous ne pouvez comparer aucune paire d'algorithmes ou d'applications.
O(1): finding the best next move in Chess (or Go for that matter). As the number of game states is finite it's only O(1) :-)
O (n log n) est la limite supérieure de la rapidité avec laquelle vous pouvez trier un ensemble arbitraire (en supposant un modèle informatique standard et non hautement parallèle).
O (2N)
O (2N) désigne un algorithme dont la croissance double avec chaque ajout à l'ensemble de données en entrée. La courbe de croissance d’un O (2N) la fonction est exponentielle - commençant très peu profonde, puis remontant de façon météorique. Un exemple de O (2N) 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);
}
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 d'un tableau prend 0(1) temps. L'opération push dans une pile prend 0(1) temps . 0 (nlogn) - Tri de fusion. trier en python prend du temps nlogn. Ainsi, lorsque vous utilisez listname.sort (), cela prend du temps.
La recherche de notes dans une table de hachage prend parfois plus que du temps constant à cause des collisions.