Juste improbable tri par fusion , QuickSort est un algorithme diviser pour régner . Il sélectionne un élément comme pivot et partitionne le tableau donné autour du pivot choisi.
Il existe de nombreuses versions différentes de quickSort qui sélectionnent le pivot de différentes manières.
- Choisissez toujours le premier élément comme pivot
- Choisissez toujours le dernier élément comme pivot
- Choisissez un élément aléatoire comme pivot
- Choisir la médiane comme pivot
Ici, nous choisirons le dernier élément comme pivot. Le processus clé dans quickSort est partition(). La cible des partitions est, étant donné un tableau et un élément « x » du tableau comme pivot, de placer x à sa position correcte dans un tableau trié et de placer tous les éléments plus petits (plus petits que x) avant x, et de placer tous les éléments plus grands (plus grands que x). que x) après x. Tout cela doit se faire en temps linéaire.
Python Tri rapide récursif fonction
// low -->Index de départ, // élevé --> Index de fin quickSort(arr[], low, high) { // Jusqu'à ce que l'index de départ soit inférieur à l'index de fin if (low // pi est l'index de partitionnement, // arr[p] est maintenant au bon endroit pi = partition(arr, low, high); // Avant pi quickSort(arr, low, pi - 1); // Après pi quickSort(arr, pi + 1, high); Python3
# Python program for implementation of Quicksort Sort> # This implementation utilizes pivot as the last element in the nums list> # It has a pointer to keep track of the elements smaller than the pivot> # At the very end of partition() function, the pointer is swapped with the pivot> # to come up with a 'sorted' nums relative to the pivot> # Function to find the partition position> def> partition(array, low, high):> ># choose the rightmost element as pivot> >pivot>=> array[high]> ># pointer for greater element> >i>=> low>-> 1> ># traverse through all elements> ># compare each element with pivot> >for> j>in> range>(low, high):> >if> array[j] <>=> pivot:> ># If element smaller than pivot is found> ># swap it with the greater element pointed by i> >i>=> i>+> 1> ># Swapping element at i with element at j> >(array[i], array[j])>=> (array[j], array[i])> ># Swap the pivot element with the greater element specified by i> >(array[i>+> 1>], array[high])>=> (array[high], array[i>+> 1>])> ># Return the position from where partition is done> >return> i>+> 1> # function to perform quicksort> def> quickSort(array, low, high):> >if> low # Find pivot element such that # element smaller than pivot are on the left # element greater than pivot are on the right pi = partition(array, low, high) # Recursive call on the left of pivot quickSort(array, low, pi - 1) # Recursive call on the right of pivot quickSort(array, pi + 1, high) data = [1, 7, 4, 1, 10, 9, -2] print('Unsorted Array') print(data) size = len(data) quickSort(data, 0, size - 1) print('Sorted Array in Ascending Order:') print(data)> |
>Sortir
Unsorted Array [1, 7, 4, 1, 10, 9, -2] Sorted Array in Ascending Order: [-2, 1, 1, 4, 7, 9, 10]>
Complexité temporelle : Dans le pire des cas, la complexité temporelle est O(N2) et la complexité temporelle moyenne des cas est O(N log N)
Espace auxiliaire : O(1)
Tri rapide Python utilisant compréhension de liste
Le tri rapide utilisant la compréhension de liste est un algorithme récursif permettant de trier un tableau d'éléments. Il fonctionne en sélectionnant un élément pivot et en partitionnant le tableau autour du pivot, de telle sorte que tous les éléments inférieurs au pivot soient déplacés vers sa gauche et tous les éléments supérieurs au pivot soient déplacés vers sa droite. Ensuite, il applique récursivement le même processus aux sous-tableaux gauche et droit jusqu'à ce que l'ensemble du tableau soit trié.
comparaison de chaînes java
Algorithme:
1.Si le tableau d'entrée a une longueur de 0 ou 1, renvoyez le tableau tel qu'il est déjà trié.
2. Choisissez le premier élément du tableau comme élément pivot.
3.Créez deux listes vides, gauche et droite.
4.Pour chaque élément du tableau à l'exception du pivot :
un. Si l'élément est plus petit que le pivot, ajoutez-le à la liste de gauche.
b. Si l'élément est supérieur ou égal au pivot, ajoutez-le à la liste de droite.
5.Appelez de manière récursive le tri rapide sur les listes de gauche et de droite.
6.Concaténez la liste triée à gauche, l'élément pivot et la liste triée à droite.
7.Renvoyer la liste concaténée.
Python3
# Approach 2: Quicksort using list comprehension> def> quicksort(arr):> >if> len>(arr) <>=> 1>:> >return> arr> >else>:> >pivot>=> arr[>0>]> >left>=> [x>for> x>in> arr[>1>:]>if> x right = [x for x in arr[1:] if x>= pivot] return tri rapide (gauche) + [pivot] + tri rapide (droite) # Exemple d'utilisation arr = [1, 7, 4, 1, 10, 9, -2] trié_arr = tri rapide (arr) print ('Tableau trié par ordre croissant :') print(sorted_arr)> |
>
>Sortir
Sorted Array in Ascending Order: [-2, 1, 1, 4, 7, 9, 10]>
La complexité temporelle est O (n log n)
La complexité spatiale de l'algorithme est O(n)