Sort rapide vs Toi de fusion comparé

«Le but de cet article est de donner les similitudes et les différences entre le tri rapide et la fusion. L'article «Quick Sort in C», ou un titre similaire, a déjà été écrit pour Linuxhint.com /. Le titre peut être tapé dans la boîte de recherche du Linuxhint.COM Page d'accueil pour atteindre l'article. Un autre article, «Merge Sort in C», ou un titre similaire, a déjà été écrit pour Linuxhint.com /. Le titre peut être tapé dans la boîte de recherche du Linuxhint.COM Page d'accueil pour atteindre l'article. Il est conseillé au lecteur de se référer à ces deux articles pendant qu'il lit celui-ci.

Le tri rapide est un algorithme de tri. Merge Syt est un autre algorithme de tri. Le code des deux articles mentionnés ci-dessus est écrit en C. Le code de cet article est également écrit en C. Le lecteur doit en être conscient. Le tri ascendant est considéré pour les deux algorithmes de tri dans cet article."

Contenu de l'article

- Introduction - Voir ci-dessus
- Algorithmes pour le tri rapide et fusion
- Notation big-o de o (n), o (n2) et o (n.journal (n))
- Comparaison du tri rapide et fusion
- Conclusion

Algorithmes pour le tri rapide et fusion
Algorithme pour Quicksort

1) S'il n'y a qu'un seul élément dans la liste, retournez. Un élément signifie que la liste est déjà triée. L'élément zéro signifie qu'il n'y a rien à trier.
2) Avec une supposition intelligente, choisissez un élément approprié dans la liste comme pivot.
3) Partition (diviser) la liste en trois sous-listes. Faire tous les éléments de la sous-liste gauche moins que le pivot. La liste centrale n'a qu'un seul élément, qui est le pivot. Faire tous les éléments de la sous-liste droite supérieur au pivot. En mettant des éléments à gauche qui sont inférieurs au pivot, et des éléments à droite qui sont plus grands que le pivot, sans tri pur, qui est déjà un tri (dans un sens large).
4) Divisez récursivement chaque sous-liste (gauche et droite) en trois, comme dans l'étape ci-dessus, chaque ensemble de trois sous-listes ayant son propre nouveau pivot (d'un sous-liste d'élément), jusqu'à ce que la liste donnée soit parfaitement trié.

Il existe différents formulaires de codage pour l'étape 2. Un meilleur formulaire de codage conduira à un tri complet plus rapide.
Il existe différents formulaires de codage pour l'étape 3. Un meilleur formulaire de codage conduira à un tri complet plus rapide.

Algorithme pour Mergesort

1) S'il n'y a qu'un seul élément dans la liste, retournez. Un élément signifie que la liste est déjà triée. L'élément zéro signifie qu'il n'y a rien à trier.
2) Divisez récursivement la liste et ses sous-listes en deux moitiés jusqu'à ce que chaque sous-liste n'ait qu'un seul élément.
3) Trier les paires de sous-listes de gauche à droite récursivement, y compris les plus grandes paires, jusqu'à ce que toute la liste soit retrouvée mais complètement triée.

C'est la façon normale de faire Mergesort, et elle ne donne pas vraiment de place, pour différents segments de code, dans le même but que Quicksort.

Notation big-o de o (n), o (n2) et o (n.journal (n))

Sur)
Considérez le code suivant:

int n = 8;
int sum = 0;
int a [] = 1, 2, 3, 4, 5, 6, 7, 8;
pour (int i = 0; isum = sum + a [i];

printf ("% d \ n", sum);

n = 8. La sortie, la somme est 36. Dans la boucle for, il y a une opération qui est exécutée 8 fois. En notation Big-O, cette vitesse (complexité temporelle) est écrite comme,

Sur)

Considérez le code similaire suivant, où seuls les nombres impairs sont ajoutés:

int n = 8;
int sum = 0;
int a [] = 1, 2, 3, 4, 5, 6, 7, 8;
pour (int i = 0; isum = sum + a [i];

printf ("% d \ n", sum);

La sortie, en somme cette fois, est 16. Dans la boucle for, la seule opération est exécutée 4 fois, ce qui est n / 2 fois. En notation Big-O, cette vitesse (complexité temporelle) est toujours écrite comme o (n). Le nombre maximum d'opérations possibles est ce qui est considéré.

Sur²)

Considérez le code suivant qui ajoute la matrice des numéros 8 par 8:

int n = 8;
int sum = 0;
int a [] = 1, 2, 3, 4, 5, 6, 7, 8;
pour (int i = 0; ipour (int j = 0; jsum = sum + a [j];


printf ("% d \ n", sum);

La sortie, la somme, est 288. Dans la boucle for, il y a une opération qui est exécutée 8 x 8 fois = 64 fois. En notation Big-O, cette vitesse (complexité temporelle) est écrite comme,

O (n²)

Considérez le code similaire suivant, où seuls les nombres impairs de la matrice sont ajoutés:

int n = 8;
int sum = 0;
int a [] = 1, 2, 3, 4, 5, 6, 7, 8;
pour (int i = 0; ipour (int j = 0; jsum = sum + a [j];


printf ("% d \ n", sum);

La sortie, en somme cette fois, est 64. Dans la boucle for, la seule opération est exécutée 4 x 4 fois = 16 fois, ce qui est n²/4 fois. C'est plus de 8 fois (plus de n fois) mais moins de 64 fois (moins de n² fois). En notation Big-O, cette vitesse (complexité temporelle) peut encore être écrite comme o (n²). Le nombre maximum d'opérations possibles est ce qui est considéré.

Ici, ne confondez pas la somme, 64, et le nombre d'opérations, 16. Ce cas de 16 opérations, entre 8 (n) et 64 (n²), peut toujours être écrit, comme dans le paragraphe suivant.

Sur.journal (n))

Considérez la situation d'une matrice de 8 par 8, où le nombre total d'opérations est de 24. 24 peut être considéré comme étant à peu près au milieu, entre 8 (n) et 64 (n²).

Maintenant,

24 = 8xlog₂(8)
=> 24 = 8xlog₂(2³)
=> 24 = 8 × 3

Comparez maintenant,

24 = 8xlog₂(8)
avec
24 = n.enregistrer₂(n)

Pour le maximum de n², Lorsque le nombre total d'opérations se situe entre n et n², Et autour de leur milieu, en notation Big-O, cette vitesse (complexité temporelle) est mieux écrite comme n.enregistrer₂(n) au lieu de o (n²).

Comparaison du tri rapide et fusion
Nombre d'étapes dans l'algorithme

D'en haut, Quicksort a 4 étapes dans son algorithme, tandis que Mergesort a 3 étapes dans son algorithme.

Différentes façons de coder

Quick Syt a différentes façons de coder, tandis que la fusion n'a qu'un seul moyen de codage.

Complexité temporelle

La complexité du temps pour Mergesort est n.enregistrer₂(n). Sa vitesse est comparable à celle de la fonction de tri de la bibliothèque C ++ utilisée à des fins commerciales.

Lorsque la fonction de pivot médiane est utilisée pour Quicksort, la complexité temporelle est d'environ 1.188.enregistrer₂(n), supérieur à Mergesort, en supposant qu'une bonne fonction de partition est utilisée. De nombreux programmes Quicksort ont une complexité de temps plus élevée. La complexité de temps le plus des cas pour Quicksort est O (n²). Cependant, si le programme Quicksort est bien codé avec de très bons segments de code, il battrait Mergesort à la vitesse.

Conclusion

Quicksort fonctionne normalement plus lentement que Mergesort.