Python tri rapide

Un QuickSort Python sélectionne un élément pivot et divise les éléments d’un tableauen deux nouveaux tableau< em>s. Les nombres supérieurs au pivot vont dans un tableau; les nombres inférieurs au pivot vont dans un autre. Chaque tableauest trié, puis tous les tableausont fusionnés en un seul.

Il existe de nombreux algorithmes de tri que vous pouvez utiliser pour trier une liste en programmation. Il y a des Python tris par insertion, sortes de bulles, et plus encore. QuickSort est l’un des types de tri les plus courants.

Dans ce guide, nous allons parler de ce que sont les QuickSorts et de leur fonctionnement. Nous allons vous présenter un exemple de QuickSort Python afin que vous puissiez apprendre à en implémenter un.

Sans plus tarder, commençons !

Qu’est-ce qu’un QuickSort Python ?

Un algorithme Python QuickSort divise un tableau en sous-tableaux. Cet algorithme appelle ces sous-tableaux de manière récursive pour trier chaque élément de la liste. Le contenu d’un sous-tableau est déterminé par un élément pivot qui n’est pas déplacé dans un nouveau sous-tableau.

L’algorithme QuickSort divise et conquiert. Cela signifie que la t√¢che de trier une liste est décomposée en plusieurs sous-t√¢ches. √Ä la fin du tri, les résultats de ces sous-t√¢ches se rassemblent pour renvoyer une liste triée.

Dans un QuickSort, la sous-t√¢che définit un pivot pour chaque sous-liste et trie les éléments en fonction de leur valeur par rapport à le pivot.

Quand dois-je utiliser un QuickSort Python ?

Un QuickSort est utile lorsque la complexité temporelle est importante. En effet, QuickSort utilise moins d’espace mémoire que les autres algorithmes, ce qui leur donne un gain d’efficacité.

81 % des participants ont déclaré qu’ils se sentaient plus confiants quant à leurs perspectives d’emploi technologique après avoir assisté à un bootcamp. Soyez jumelé à un bootcamp aujourd’hui.

Le diplômé moyen d’un bootcamp a passé moins de six mois en transition de carrière, du démarrage d’un bootcamp à la recherche de son premier emploi.

Vous ne devez utiliser qu’un QuickSort si vous connaissez la récursion Python. En effet, l’algorithme QuickSort dépend de fonctions récursives.

Un QuickSort est plus efficace qu’un tri par fusion sur des tableaux plus petits. Cependant, sur des ensembles de données plus volumineux, un tri par insertion ou un tri par fusion peut être plus rapide.

Comment fonctionne un QuickSort ?

Un QuickSort sélectionne un élément pour servir de pivot. Il peut s’agir de n’importe quel élément d’une liste. Pour ce tutoriel , nous allons choisir le dernier élément d’une liste (3).

845213

Un QuickSort compare la valeur de pivot à chaque nombre lorsque nous parcourons les éléments de la liste. Si un élément est supérieur au numéro de pivot, nous déplaçons le nombre après le pivot ; sinon, on déplace le nombre avant le pivot :

2 13854

La valeur 3 est descendue dans notre liste. Tous les éléments de moins de 3 m à sa gauche ; toutes les valeurs supérieures à trois se sont déplacées vers sa droite.

Notre tableau Python est divisé en deux moitiés : les éléments supérieurs au pivot et les éléments moins qu’un pivot.

Une fois ce processus amorcé, un nouveau pivot commence sur chacune des deux moitiés. Ce pivot commence séparément et utilise le même algorithme que ci-dessus. Tout d’abord, nous allons définir une valeur de pivot qui est égale à la dernière valeur de chaque liste :

Ensuite, nous allons déplacer toutes les valeurs supérieures à un pivot à droite du pivot. Nous déplaçons toutes les valeurs inférieures au pivot vers la gauche.

Pivot One

Pivot Deux

12
485

Ce processus se poursuit jusqu’à ce que nous triions notre liste :

Première fois12
4 85
Deuxième fois
1

85





587t ?/
Troisième Heure




8

Notre tableau final ressemble à ceci :

123458

Exemple Python QuickSort

Le QuickSort a besoin de deux fonctions : une fonction pivot et une fonction QuickSort.

Commençons par la fonction de partition. Cela partitionnera ou préparera le tableau en fonction de la valeur de l’élément pivot.

Notre fonction de partition :

  1. Sélectionnez l’élément pivot
  2. Déplacer tous les éléments supérieurs au pivot à droite du pivot
  3. Déplacer tous les éléments inférieurs au pivot à gauche du pivot

Programme Python QuickSort

√âcrivons un programme qui implémente cet algorithme :

Tout d’abord, nous sélectionnons un élément pivot. Ceci est égal au nombre le plus élevé de notre liste.

Ensuite, nous parcourons tous les éléments de la liste à l’aide d’une Python for loop. Si un nombre est inférieur ou égal au pivot, il est déplacé à gauche du pivot. Sinon, il va à droite du pivot.

Notre fonction Python renvoie la nouvelle valeur élevée. La nouvelle valeur élevée est égale à l’élément + 1.

Ensuite, nous devons exécuter notre algorithme. Nous pouvons le faire en écrivant une fonction distincte :

"Career Karma est entré dans ma vie au moment o√π j’en avais le plus besoin et m’a rapidement aidé à suivre un bootcamp. Deux mois après avoir obtenu mon diplôme, j’ai trouvé l’emploi de mes rêves qui correspondait à mes valeurs et à mes objectifs dans la vie !"

Venus, ingénieur logiciel chez Rockbot

Cette fonction vérifie si la valeur de "faible" est inférieure à la valeur de "élevée". Si c’est le cas, notre tri peut continuer. Sinon, notre tri s’arrête. Si notre tri s’arrête, cela signifie que nous avons trié la liste.

Ensuite, notre fonction appelle la méthode prepare(). Cela identifie un pointeur pour le pivot et déplace les éléments à leur place correcte.

Notre fonction appelle ensuite deux fois la méthode quick_sort(). La première fois, on lance le QuickSort sur les éléments à gauche du pivot. La deuxième fois, on lance le QuickSort sur les éléments à à droite du pivot. Par conséquent, notre fonction est récursive car elle s’appelle elle-même.

Cela continue jusqu’à ce que chaque élément de la liste soit trié.

√âcrire une méthode principale

√âcrivons un programme principal qui définit une liste pour rt :

Tout d’abord, nous spécifions une liste de valeurs à trier. Nous utilisons la méthode Python len() pour calculer la longueur de notre liste de valeurs. Ensuite, nous appelons la méthode quick_sort().

Nous passons "valeurs" comme nombres que nous voulons trier. Nous passons ensuite 0 comme nombre inférieur. La longueur des "valeurs" moins 1 est la valeur haute que nous spécifions. La valeur haute est la longueur des valeurs moins 1, car le premier élément d’une liste a le numéro d’index 0.

Essayons d’exécuter notre programme :

Notre code renvoie une liste triée ! Nous l’avons fait. Donnez-vous une tape dans le dos. Les QuickSort ne sont pas faciles à comprendre ou à mettre en ≈ìuvre.

Présentation de la complexité

En moyenne, cet algorithme fonctionnera à O(n* log n). Cela se produit lorsque l’élément pivot n’est pas le plus grand ou le plus petit élément et lorsque l’élément pivot n’est pas près de l’élément central.

Le QuickSort a le pire des cas com plexité de O(n2). Cela se produit lorsque l’élément sélectionné comme pivot est le plus grand ou le plus petit élément. Si tel est le cas, l’élément pivot sera toujours à la fin d’un tableau trié. Cela créera un certain nombre de sous-tableaux inutiles.

Le meilleur cas de complexité pour cet algorithme est O(n* log n). Cela se produit lorsque l’élément pivot est égal à l’élément central ou proche de l’élément central.

Pour en savoir plus sur la complexité des algorithmes, consultez notre guide sur Big O Notation.

Conclusion

Python QuickSorts utilise la récursivité pour décomposer une liste en listes plus petites qui sont ensuite triées. Chaque liste est triée autour d’un élément pivot. Les éléments supérieurs au pivot sont déplacés vers sa droite ; les éléments plus petits sont déplacés vers la gauche du pivot.

Pour obtenir des conseils sur les meilleures ressources d’apprentissage Python, les cours en ligne et les livres, lisez notre Comment apprendre le guide Python.