Quels sont certains 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 / 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

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.

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!

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"

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) :-)

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.

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)
{
    .
    .
    .
}

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

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 (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.

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);
}