L'ordre de complexité est un terme utilisé en informatique pour mesurer l'efficacité d'un algorithme ou d'un programme. Il fait référence au temps et aux ressources nécessaires pour résoudre un problème ou effectuer une tâche. En programmation, l'ordre de complexité est généralement exprimé en termes de Grand O notation, qui donne une limite supérieure sur les exigences de temps ou d'espace d'un algorithme. Dans cet article, nous discuterons de l'ordre de complexité dans le langage de programmation C et de sa signification.
liste des religions
Ordre de complexité dans le langage de programmation C :
En programmation C, l'ordre de complexité d'un algorithme dépend du nombre d'opérations effectuées par le programme. Par exemple, si nous avons un tableau de taille n et que nous voulons rechercher un élément particulier dans le tableau, l'ordre de complexité de l'algorithme dépendra du nombre d'éléments dans le tableau. Si nous effectuons une Recherche linéaire à travers le tableau, l'ordre de complexité sera Sur) , ce qui signifie que le temps nécessaire à la recherche de l'élément augmentera linéairement avec la taille du tableau. Si nous utilisons un Algorithme de recherche binaire au lieu de cela, l'ordre de complexité sera O (log n) , ce qui signifie que le temps nécessaire à la recherche de l'élément augmentera de manière logarithmique avec la taille du tableau.
De même, l'ordre de complexité d'autres algorithmes, tels que Algorithmes de tri , Algorithmes graphiques , et Algorithmes de programmation dynamique dépend également du nombre d'opérations effectuées par le programme. L'ordre de complexité de ces algorithmes peut être exprimé en utilisant Grand O notation.
Jetons un coup d'œil à quelques ordres de complexité courants et à leurs algorithmes correspondants :
Cela signifie que l'algorithme prend un temps constant, quelle que soit la taille de l'entrée. Par exemple, accéder à un élément d'un tableau prend O(1) temps, car l’élément est accessible directement à l’aide de son index.
Cela signifie que le temps nécessaire à l'algorithme augmente de manière logarithmique avec la taille de l'entrée. Ceci est couramment observé dans Algorithmes diviser pour régner comme Recherche binaire , qui divise l'entrée en parties plus petites pour résoudre le problème.
chaîne de liste Java
Cela signifie que le temps nécessaire à l'algorithme augmente linéairement avec la taille de l'entrée. Des exemples de tels algorithmes sont Recherche linéaire et Tri à bulles .
Cela signifie que le temps nécessaire à l'algorithme augmente de n multiplié par le logarithme de n. Des exemples de tels algorithmes sont Tri rapide et Tri par fusion .
Cela signifie que le temps nécessaire à l'algorithme augmente quadratiquement avec la taille d'entrée. Des exemples de tels algorithmes sont Tri à bulles et Tri par insertion .
Cela signifie que le temps nécessaire à l'algorithme double à chaque augmentation de la taille d'entrée. Ceci est couramment observé dans Algorithmes récursifs comme le Série Fibonacci .
Internet utilisant
Il est important de savoir que l’Ordre de Complexité ne fournit qu’une limite supérieure sur le temps pris par l’algorithme. Le temps réel pris peut être bien inférieur à cette limite, en fonction des données d'entrée et de la mise en œuvre de l'algorithme.
En programmation C, l'ordre de complexité d'un algorithme peut être déterminé en analysant le code et en comptant le nombre d'opérations effectuées. Par exemple, si nous avons une boucle qui parcourt un tableau de taille n, la complexité temporelle de la boucle sera Sur) . De même, si nous avons une fonction récursive qui s’appelle k fois, la complexité temporelle de la fonction sera O(2^k) .
Pour optimiser les performances d’un programme, il est important de choisir des algorithmes avec un ordre de complexité inférieur. Par exemple, si nous devons trier un tableau, nous devons utiliser un algorithme de tri avec un ordre de complexité inférieur, tel que Tri rapide ou Tri par fusion , plutôt que Tri à bulles , qui a un ordre de complexité plus élevé.
Analyse de l'ordre de complexité :
Pour analyser l'ordre de complexité d'un algorithme, nous devons déterminer comment son temps d'exécution ou son utilisation de l'espace augmente à mesure que la taille de l'entrée augmente. La méthode la plus courante pour y parvenir consiste à compter le nombre d’opérations de base effectuées par l’algorithme.
algorithme de Bellford
Une opération de base est une opération qui prend un temps constant, comme l’ajout de deux nombres ou l’accès à un élément d’un tableau. En comptant le nombre d'opérations de base effectuées par l'algorithme en fonction de la taille de l'entrée, nous pouvons déterminer son ordre de complexité.
Par exemple, considérons la fonction C suivante qui calcule la somme des n premiers entiers :
Code C :
int sum(int n) { int total = 0; for (int i = 1; i <= n; i++) { total +="i;" } return total; < pre> <p>In this function, the loop runs n times, and each iteration performs a constant amount of work (adding i to the total). Therefore, the number of basic operations performed by this algorithm is proportional to n, and its time complexity is <strong>O(n)</strong> .</p> <hr></=>