préambule:
Un algorithme de tri à bulles
Deux réalisation du programme de tri à bulles
Trois algorithme de tri rapide
Quatre algorithme de tri rapide réalisation du programme
Le premier algorithme de tri à bulles
brève introduction
Bubble Trier (Bubble Trier), est une science informatique champ algorithme de tri plus simple .
Il a visité à plusieurs reprises des éléments de la colonne pour trier, afin de comparer deux éléments adjacents, si leur ordre (comme descendant, la première lettre de A à Z) erreurs qu'ils échangent a repris. élément de visite de travail se répète jusqu'à ce qu'il n'y a pas besoin d'échanger des éléments adjacents, c'est-à-dire la colonne de l'élément a été réglé terminé.
Le nom vient de l'algorithme de fait des éléments de plus grande taille progressivement échanger par l'intermédiaire d'un « flotter » au début du numéro de colonne (croissant ou décroissant), comme si le dioxyde de carbone des bulles dans une boisson gazeuse éventuellement flotter à la surface de la même, d'où le nom « bulle trier ".
principe
Principe algorithme de tri à bulles est la suivante:
-
Comparer des éléments adjacents. Si la première est supérieure à la seconde, les deux échangèrent.
-
Faire le même travail pour chaque paire d'éléments adjacents, à partir du début de la première paire à la fin de la dernière paire. À ce stade, il devrait être le dernier élément est le plus grand nombre.
-
Répétez ces étapes pour tous les éléments, à l'exception du dernier.
-
Continué à répéter les étapes ci-dessus pour chaque fois de moins en moins d'éléments, une paire de nombres jusqu'à ce qu'il n'y a pas besoin de comparer.
algorithme d'analyse
complexité du temps
Si l'état initial est le fichier de séquence positive, un laissez - passer pour compléter l'ordre. Le nombre de comparaisons nécessaires mots - clés 
et enregistrer le nombre de mobiles 
Ont atteint un minimum:
,
.
Par conséquent, le meilleur type de bulle complexité temporelle est 
.
Si le fichier d' origine est dans l' ordre inverse, la nécessité de
Tri voyage. Pour trier par voyage
Comparaison des temps d'un mot-clé (1≤i≤n-1), et enregistrer chaque comparaison doit être déplacé trois fois pour atteindre la position de change dossier. Dans ce cas, la comparaison et atteint le nombre maximum de mobile:
La pire complexité temporelle de tri à bulles est
.
[1] En résumé, donc la complexité du temps de tri moyenne globale de bulle est
.
stabilité algorithme
Bubble est en quelque sorte les petits éléments se déplacent vers l'avant ou vers l'arrière dans les grands éléments. Comparaison de deux éléments adjacents est plus, outre l'échange se produit entre ces deux éléments. Par conséquent, si les deux éléments sont égaux, l'échange ne sera pas, si deux éléments égaux adjacents, même si l'avant par échange par paires les deux up adjacentes, cette fois-ci ne sera pas échangé, les mêmes éléments avant et après l'ordre n'a pas changé, de sorte que la bulle est en quelque sorte un algorithme de tri stable.
Le deuxième algorithme de tri à bulles
langage C
#include <stdio.h>
#define ARR_LEN 255 / * longueur maximale de la rangée * /
#define elemType int / * Type d' élément * /
/ * bulle tri * /
/ * 1. À partir de l'élément en cours, en comparant séquentiellement chacune vers l' arrière élément adjacent, si la commutation inverse * /
/ * 2. répéter les étapes ci - dessus pour tous les éléments, jusqu'à ce que le dernier élément * /
/ * elemType ARR []: le tri du tableau cible; int len: le nombre d'éléments * /
BubbleSort vide (elemType ARR [], int len) {
elemType TEMP;
int I, J;
for (i = 0; I <len-1; I ++) / * la boucle externe est de trier le nombre de tours, le nombre len pour LEN-1 fois * /
pour (j = 0; j <. Len- 1-i; J ++) {/ * la boucle interne est le nombre de fois par comparaison de voyage, le i-ième comparateur de déclenchement fois lEN-i * /
IF (ARR [J]> ARR [J + 1]) {/ * on compare les éléments adjacents, alors le commutateur lorsque la commande de marche arrière (supérieur au droit de l'ascendant gauche, descendant , et vice - versa) * /
TEMP = ARR [J];
ARR [J] = ARR [J + 1];
ARR [J + . 1] = TEMP;
}
}
}
int main (void) {
elemType arr [ARR_LEN] = {3,5,1, -7,4,9, -6,8,10,4};
int len = 10;
int i;
BubbleSort (arr, len);
for (i = 0; i <len; i ++)
printf ( "% d \ t", arr [i]);
putchar ( '\ n');
return 0;
}
3 rapide algorithme de tri
tri rapide (Quicksort) est une amélioration sur le type de bulle.
tri rapide proposé par CAR Hoare en 1960. L'idée de base est: un voyage en commandant les données à trier en deux parties indépendantes, la partie où toutes les données que l'autre partie de toutes les données soient petites, cette méthode de données pour les deux parties séparément rapide le tri, l'ensemble du processus de tri peut être récursive, afin d'obtenir l'ensemble des données dans une séquence ordonnée.
Est prévu pour trier le tableau a [0] ...... A [N-1], sélectionner l'une des premières données des données (le premier nombre est un tableau généralement choisi) en tant que clé, puis tout cela est plus petit que le nombre de qui sont placées dans à gauche, plus grand que tous ses numéros sont mis à sa droite, un processus connu sous le nom d'un voyage à tri rapide. Il est à noter que, tri rapide est pas un algorithme de tri stable, qui est, aux mêmes positions relatives de la pluralité de valeurs peut fluctuer à la fin de l'algorithme.
Un voyage à l'algorithme de tri rapide est:
1) Ensemble de deux variables i, j, au début de la sorte: i = 0, j = N-1;
2) au premier élément de réseau en tant que données clés, attribué à Key , c.- à - Key = A [0];
3) Recherche vers l' avant à partir de j, à savoir, à partir de la recherche vers l' avant (J,), pour trouver une moins première clé valeur A [j], A [j] et A [i] échange de valeur;
4) commence à partir du retour Recherche i, à savoir, avant le début de la recherche en arrière (i ++), trouver le premier est plus grande que la clé de A [i], A [i] et l' échange de la valeur A [j];
5) Répéter les étapes 3 et 4 jusqu'à ce que i = j; (3,4 étape, n'a pas trouvé la valeur admissible, à savoir 3 A [j] ne soit pas inférieure à la clé , dans 4 A [i] ne dépasse pas la. Touche temps changer j, la valeur de i tel que j = j-1, i = i + 1, jusqu'à ce que vous trouverez trouvé la valeur qualifiée, lorsque l'échange de i, la position du pointeur j inchangé. de plus, i == j que processus doit être exactement le temps i + j- ou terminé, de sorte qu'à ce moment la fin du cycle).
Peut fonctionner qsort () peut être commandé directement tableau en langage C.
utilisation:
qsort vide (base void *, int nelem, largeur int, int (* fcmp) (* const vide, const void *));
Paramètres:
une première adresse devant être triés tableau
2 comme numéro d'élément de tableau trié
3 dans l'empreinte de la taille de chaque élément
pointeur de 4 périodes de une fonction pour déterminer séquentiellement une commande
complexité du temps
la complexité du temps le plus optimiste de O (n log n), le processus est plus complexe, il ne se répète pas ici.
Chaque prise le pire des cas pour le numéro (numéro de référence) est la valeur maximale / minimale du courant à comparer est, dans ce cas, à chaque fois seulement pour obtenir un numéro de séquence inférieur au 1 (à savoir, soit tout plus grand que le numéro de référence, ou plus petite que la référence complète), puis une bulle est en quelque sorte l'équivalent, le nombre de comparaisons = (n - 1) + (n - 2) + ... + 2 + 1 = ( n - 1) * n / 2, dans cette complexité temporelle de cas est la suivante: O (n ^ 2). Habituellement, il apparaît dans le pire des cas: être données lui-même est déjà triées une bonne séquence positive ou d'une ligne de l'ordre inverse.
complexité espace
c'est en fait, pas un calcul bien de la complexité spatiale, parce que certaines personnes utilisent le tri non-lieu, calculé comme mauvais (parce que certaines personnes ont utilisé le réseau auxiliaire, il est donc nécessaire de calculer le nombre de votre élément) , je vais analyser dans l'espace in situ sous la complexité de quicksort de celui-ci;
espace quicksort premier lieu utilisé est O (1), ce qui est un niveau constant, et l'espace réel est consommé par des appels récursifs, parce que chaque nécessaire récursive pour maintenir certaines des données;
La complexité optimale de l'espace du boîtier: O (logn), coupe le réseau chaque fois qu'un cas
La pire complexité de l'espace de cas est: O (n), cas dégénéré de tri à bulles
Quatrième algorithme réalisation du programme de tri rapide
Le tri rapide plus rapide, parce que par rapport à bulles sorte, chaque échange est pas de géant. Chaque fois que le tri d'un point de référence défini, le point de référence sera inférieur ou égal au nombre de tous à gauche du point de référence, le point de référence sera supérieur au nombre égal à la référence totale dans le point droit. Donc, chaque fois que l'échange ne sera pas le même que le tri à bulles ne peuvent être échangées entre les numéros adjacents de l'échange du grand plus. Par conséquent, le nombre total de comparaison et d'échange ont moins de vitesse naturelle serait augmentée. Bien sûr, dans le pire des cas, il peut encore être numéro deux adjacents ont été échangées. Ainsi, la complexité dans le pire temps de tri rapide et tri à bulles est le même est O (N2), sa complexité temporelle moyenne de O (NlogN).
tri rapide:
#include <stdio.h>
int A [101], n; // définir des variables globales, ces variables nécessite l'utilisation de deux sous-fonctions dans
quicksort void (int gauche, à droite int) {
int I, J, T, TEMP,
IF (gauche> droite)
retour;
TEMP = a [gauche]; // TEMP est stocké dans le numéro de référence
I = gauche,
J = droite,
le temps (! I = J) {// ordre est important, d' abord le droit de trouver
le temps (un [J]> = TEMP && I <J)
J ,;
le temps (un [I] <= TEMP && I <J) // trouve le droit
I ++;
IF (I < j) // Lieux d'échange dans les deux numéros de tableau
{
T = a [I],
un [I] = a [J],
un [J] = T;
}
}
// homing numéros de référence éventuellement
un [ gauche] = a [i];
A [I] = TEMP;
tri rapide ( à gauche ,. 1-I); // poursuivre le traitement de la gauche, il y a un processus récursif
tri rapide (i + 1, à droite) ; // poursuivre le traitement de la droite, il y a un récursif procédé
}
int main () {
int i;
// données de lecture
Scanf ( "% D", et n-);
for (i = 1;. I <= N-; I ++)
Scanf ( "% D", et A [I]) ; le
tri rapide (1, n.); // appel tri rapide
après // trie la sortie
pour (i = 1;. I <n-; I ++)
printf ( "% D", a [i]);
le printf ( « % D \ n- », A [n-]);
return 0;
}
