Chapitre 7 Algorithmes de tri (1) (Introduction, Classification, Complexité temporelle, Complexité spatiale)

7.1 Introduction aux algorithmes de tri

Le tri est également appelé algorithme de tri (Algorithme de tri). Le tri est le processus consistant à organiser un ensemble de données dans un ordre spécifié .

7.2 Classement du tri :

1. Tri interne :
   fait référence au chargement de toutes les données qui doivent être traitées dans la **mémoire interne (mémoire)** pour le tri.
2. Méthode de tri externe :
   la quantité de données est trop importante pour être chargée dans la mémoire et doit être triée à l'aide d'un **stockage externe (fichiers, etc.).
3. Classification des algorithmes de tri courants (voir l'image de droite) :
   

7.3 Complexité temporelle de l'algorithme

7.3.1 Deux façons de mesurer le temps d'exécution d'un programme (algorithme)

1. La méthode des statistiques post-événement est réalisable, mais elle pose deux problèmes : le premier est que pour évaluer les performances d'exécution de l'algorithme conçu, le programme doit être réellement exécuté ; l'autre est que les statistiques du temps obtenu dépendent de le matériel, les logiciels, etc. de l'ordinateur. Facteurs environnementaux, de cette manière, il est nécessaire de fonctionner sur le même ordinateur dans le même état pour comparer quel algorithme est le plus rapide.

2. La méthode de pré-estimation juge quel algorithme est le meilleur
   en analysant la complexité temporelle d'un algorithme.

7.3.2 Fréquence temporelle

introduction de base

Fréquence temporelle : Le temps passé par un algorithme est proportionnel au nombre d'exécutions des instructions dans l'algorithme. Quel que soit l'algorithme qui exécute les instructions le plus souvent, cela prend plus de temps.
Le nombre d’exécutions d’instructions dans un algorithme est appelé fréquence d’instruction ou fréquence temporelle. Notons-le comme T(n) . [Par exemple]

Exemple - cas de base

Par exemple, pour calculer la somme de tous les nombres de 1 à 100, nous concevons deux algorithmes :

Exemple - ignorer les termes constants

Conclusion :
2n+20 et 2n à mesure que n grandit, la courbe d'exécution se rapproche de l'infini, 20 peut être ignoré
3n+10 et 3n À mesure que n grandit, la courbe d'exécution se rapproche de l'infini, 10 peut être ignoré

Exemple – Ignorer les conditions de commande inférieures

Conclusion :
2n^2+3n+10 et 2n^2 sont infiniment proches des courbes d'exécution à mesure que n devient plus grand, et 3n+10
n^2+5n+20 et n^2 sont infiniment proches des courbes d'exécution à mesure que n devient plus grand, peut ignorer 5n+20

Exemple - Ignorer les coefficients

Conclusion :
à mesure que la valeur de n devient plus grande, 5n^2+7n et 3n^2 + 2n, la courbe d'exécution coïncide, indiquant que dans ce cas, 5 et 3 peuvent être ignorés.
Et n^3+5n et 6n^3+4n, effectuez une séparation de courbe, expliquez combien de fois le mode est critique

7.3.3 Complexité temporelle

1. En général, les temps d'exécution répétés de l'instruction d'opération de base dans l'algorithme sont fonction de la taille du problème n , noté T(n), s'il existe une fonction auxiliaire f(n), de sorte que lorsque n s'approche de l'infini, le la valeur limite de T(n) / f(n) est une constante non égale à zéro, alors f(n) est dit être une fonction de même ampleur que T(n). Il est enregistré sous la forme T(n)=O(f(n)) , et O(f(n)) est appelé la complexité temporelle asymptotique de l'algorithme, appelée complexité temporelle.

2. T(n) est différent, mais la complexité temporelle peut être la même. Par exemple : T(n)=n²+7n+6 et T(n)=3n²+2n+2 ont des T(n) différents, mais la complexité temporelle est la même, les deux sont O(n² ) .

3. La méthode pour calculer la complexité temporelle :

• Remplacez toutes les constantes additives au moment de l'exécution par la constante 1 T(n)=n²+7n+6 => T(n)=n²+7n+1
• Dans la fonction temps de course modifiés, seul le terme d'ordre le plus élevé T(n)=n²+7n+1 => T(n) = n² est conservé
• Supprimer le coefficient du terme d'ordre le plus élevé T(n) = n² => T(n) = n² => O(n²)

7.3.4 Complexités temporelles courantes

1. Ordre constant O(1)
2. Ordre logarithmique O(log2n)
3. Ordre linéaire O(n)
4. Ordre linéaire-logarithmique O(nlog2n)
5. Ordre carré O(n^2)
6. Ordre cubique O(n^3)
7. kième ordre O(n^k)
8. Ordre exponentiel O(2^n)

Le graphique correspondant à la complexité temporelle commune :

illustrer:

1. La complexité temporelle des algorithmes courants, du plus petit au plus grand, est : Ο(1)<O(log2n)<O(n)<O(nlog2n)<O(n2)<O(n3)< Ο(nk) <O( 2n ), à mesure que l'échelle du problème n augmente, la complexité temporelle mentionnée ci-dessus augmente continuellement et l'efficacité d'exécution de l'algorithme diminue
2. La figure montre que nous devrions éviter autant que possible d'utiliser des algorithmes d'ordre exponentiel.

1) Ordre constant O(1)

Quel que soit le nombre de lignes de code exécutées, tant qu'il n'y a pas de structures complexes telles que des boucles, la complexité temporelle de ce code est O(1)

Lorsque le code ci-dessus est exécuté, sa consommation n'augmente pas avec la croissance d'une certaine variable, donc peu importe la durée de ce type de code, même s'il y a des dizaines de milliers ou des centaines de milliers de lignes, il peut être représenté par O(1) complexité temporelle.

2) Ordre logarithmique O(log2n)

Explication : Dans la boucle while, i est à chaque fois multiplié par 2. Après la multiplication, i se rapproche de n. En supposant qu'après avoir bouclé x fois, i est supérieur à 2 et que la boucle se termine à ce moment-là, c'est-à-dire que la puissance x de 2 est égale à n, alors x = log2n, c'est-à-dire après avoir bouclé log2n fois , le code se termine. La complexité temporelle de ce code est donc : O(log2n). Ce 2 temps de O(log2n) est modifié selon le code, i = i * 3, c'est O(log3n).

3) Ordre linéaire O(n)

Explication : Dans ce code, le code de la boucle for sera exécuté n fois, donc le temps qu'il consomme varie avec le changement de n, donc ce type de code peut utiliser O(n) pour exprimer sa complexité temporelle

4) Ordre logarithmique linéaire O(nlogN)

Explication : L'ordre logarithmique linéaire O(nlogN) est en fait très facile à comprendre. Si le code avec une complexité temporelle de O(logn) est cyclé N fois, alors sa complexité temporelle est n * O(logN), c'est-à-dire O ( nlogN)

5) Ordre carré O(n²)

Explication : L'ordre carré O(n²) est plus facile à comprendre. Si le code O(n) est imbriqué et bouclé à nouveau, sa complexité temporelle est O(n²). Ce code est en fait imbriqué avec 2 couches de n Boucle, son temps la complexité est O(n n), c'est-à-dire O(n²) Si n d'une couche de boucle est remplacé par m, alors sa complexité temporelle devient O(m n)

6) Ordre cubique O(n³), Kième ordre O(n^k)

Explication : Il suffit de se référer au O(n²) ci-dessus pour comprendre, O(n³) équivaut à trois couches de n boucles, d'autres sont similaires

7.3.5 Complexité temporelle moyenne et pire complexité temporelle

1. La complexité temporelle moyenne est le temps d'exécution de l'algorithme lorsque toutes les instances d'entrée possibles se produisent avec une probabilité égale.
2. La complexité temporelle dans le pire des cas est appelée la pire complexité temporelle. La complexité temporelle généralement discutée est la complexité temporelle dans le pire des cas . La raison en est la suivante : la complexité temporelle dans le pire des cas est la limite du temps d'exécution de l'algorithme sur n'importe quelle instance d'entrée, ce qui garantit que le temps d'exécution de l'algorithme ne sera pas plus long que le pire des cas.
3. La cohérence de la complexité temporelle moyenne avec la pire complexité temporelle est liée à l'algorithme (comme le montre la figure :).
   

7.4 Introduction à la complexité spatiale des algorithmes

7.4.1 Introduction de base

1. Semblable à la discussion sur la complexité temporelle, la complexité spatiale d'un algorithme (Space Complexity) est définie comme l'espace de stockage consommé par l'algorithme, qui est également fonction de la taille du problème n.
2. La complexité spatiale (Space Complexity) est une mesure de la taille de l'espace de stockage temporairement occupé par un algorithme pendant son fonctionnement. Le nombre d'unités de travail temporaires que certains algorithmes doivent occuper est lié à l'échelle n du problème à résoudre. Il augmente avec l'augmentation de n. Lorsque n est grand, il occupera plus d'unités de stockage, comme le tri rapide et les algorithmes de tri par fusion , ce qui est le cas du
3. Lors de l’analyse d’algorithmes, la discussion principale est la complexité temporelle. Du point de vue de l'expérience utilisateur, la vitesse d'exécution du programme est plus importante . Certains produits de mise en cache (redis, memcache) et algorithmes (tri par base) échangent essentiellement de l'espace contre du temps .