Tri rapide Vs Fusionner le sorting

Pourquoi un sorting rapide serait-il préférable à un sorting par fusion?

Voir Quicksort sur wikipedia :

En général, le sorting rapide est beaucoup plus rapide dans la pratique que les autres algorithmes because (nlogn), car sa boucle interne peut être efficacement implémentée dans la plupart des architectures et dans la plupart des données réelles. temps.

Notez que l’exigence de mémoire très faible est également un gros plus.

Le sorting rapide est généralement plus rapide que le sorting par fusion lorsque les données sont stockées en mémoire. Cependant, lorsque le jeu de données est volumineux et stocké sur des périphériques externes tels qu’un disque dur, le sorting par fusion est clairement la solution la plus rapide. Il minimise les lectures coûteuses du disque externe et se prête bien au calcul parallèle.

Pour le type de fusion, le pire des cas est O(n*log(n)) , pour Tri rapide: O(n 2 ) . Pour les autres cas (avg, meilleur), les deux ont O(n*log(n)) . Cependant, le sorting rapide est une constante d’espace où le sorting par fusion dépend de la structure que vous sortingez.

Voir cette comparaison .

Vous pouvez aussi le voir visuellement .

Personnellement, je voulais tester moi-même la différence entre le sorting rapide et le sorting par fusion et j’ai vu les temps d’exécution d’un échantillon de 1 000 000 d’éléments.

Le sorting rapide était capable de le faire en 156 millisecondes alors que le sorting par fusion faisait la même chose en 247 millisecondes

Cependant, les données de sorting rapide étaient aléatoires et le sorting rapide s’effectue correctement si les données sont aléatoires, ce qui n’est pas le cas avec le sorting de fusion, c’est-à-dire que le sorting fusionne ou non. Mais le sorting par fusion nécessite un espace supplémentaire complet et un sorting rapide ne constitue pas un sorting sur place

J’ai écrit un programme de travail complet pour eux et des images illustratives.

Bien que le sorting rapide soit souvent un meilleur choix que le sorting par fusion, il est certain que le sorting par fusion est un meilleur choix. Le moment le plus évident est celui où il est extrêmement important que votre algorithme fonctionne plus vite que O (n ^ 2). Quicksort est généralement plus rapide que cela, mais compte tenu de la pire entrée théorique possible, il pourrait s’exécuter en O (n ^ 2), ce qui est pire que le pire sorting de fusion possible.

Quicksort est également plus compliqué que fusesort, surtout si vous voulez écrire une implémentation vraiment solide, donc si vous visez la simplicité et la maintenabilité, le sorting par fusion devient une alternative prometteuse avec très peu de perte de performance.

Outre les autres: le sorting par fusion est très efficace pour les structures de données immuables telles que les listes chaînées et constitue donc un bon choix pour les langages de programmation (purement fonctionnels).

Un quicksort mal implémenté peut constituer un risque de sécurité .

Quicksort est en place. Il vous suffit de permuter les positions des données pendant la fonction de partitionnement. Mergesort nécessite beaucoup plus de copie de données. Vous avez besoin d’un autre stockage temporaire (généralement de la même taille que votre tableau de données d’origine) pour la fonction Fusion.

QuickSort est nommé ainsi pour une raison,

faits saillants: les deux sont des sortes stables, (simplement une nuisance d’implémentation), alors passons simplement à la complexité

c’est très déroutant avec juste les notations de big-oh qui sont déversées et “abusées”, les deux ont une complexité de cas moyenne de 0 (nlogn),

mais le sorting par fusion est toujours 0 (nlogn), alors que le sorting rapide pour les mauvaises partitions, c.-à-d. les partitions asymésortingques comme 1 élément-10 (qui peut être sortingé ou inversé) peut donner un 0 (n ^ 2).

.. et donc nous avons randomisé le sorting rapide, où nous choisissons le pivot de manière aléatoire et évitons un tel partitionnement asymésortingque, annulant de ce fait tout le scénario n ^ 2 même pour un partitionnement modérément asymésortingque comme 3-4, nous avons un nlog (7/4) n , idéalement nous voulons 1-1 partion, donc tout 2 de O (nlog (2) n).

donc il est O (nlogn), presque toujours et contrairement au sorting par fusion, les constantes cachées sous la notation “big-oh” sont meilleures pour le sorting rapide que pour la fusion .. et il n’utilise pas d’espace supplémentaire comme le sorting par fusion.

mais pour que l’exécution rapide s’exécute parfaitement, il faut peaufiner, reformuler, le sorting rapide vous offre la possibilité de modifier …

La réponse serait légèrement orientée vers le quicksort par rapport aux changements apportés avec DualPivotQuickSort pour les valeurs primitives. Il est utilisé dans JAVA 7 pour sortinger dans java.util.Arrays

 It is proved that for the Dual-Pivot Quicksort the average number of comparisons is 2*n*ln(n), the average number of swaps is 0.8*n*ln(n), whereas classical Quicksort algorithm has 2*n*ln(n) and 1*n*ln(n) respectively. Full mathematical proof see in attached proof.txt and proof_add.txt files. Theoretical results are also confirmed by experimental counting of the operations. 

Vous pouvez trouver l’implémentation de JAVA7 ici – http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/7-b147/java/util/Arrays.java

Plus de lecture géniale sur DualPivotQuickSort – http://permalink.gmane.org/gmane.comp.java.openjdk.core-libs.devel/2628

Ce n’est pas vrai que le sorting rapide est meilleur. Aussi, cela dépend de ce que vous voulez dire, de la consommation de mémoire ou de la vitesse.

En termes de consommation de mémoire, dans le pire des cas, mais le sorting rapide peut utiliser la mémoire n ^ 2 (c.-à-d. Chaque partition vaut 1 à n-1), alors que le sorting par fusion utilise nlogn.

Ce qui précède suit en termes de vitesse.

Quicksort est en place. Vous avez besoin de très peu de mémoire supplémentaire. Ce qui est extrêmement important.

Un bon choix de médiane le rend encore plus efficace, mais même un mauvais choix de quarante médailles Theta (nlogn).