En effet, sur la base de la comparaison et d' échange algorithme de tri, ce qui limite la complexité en temps est O (nlog 2 N- ). Bubble tri, tri par insertion, etc. Inutile de dire que la complexité est en O (n 2 ), même aussi forte que tri rapide, tas sorte, aussi atteint que O (nlog 2 n complexité) de. Ensuite , ceux qui peuvent traverser le légendaire O (nlog 2 du n ) limite, à la complexité temporelle linéaire O (n) de l' algorithme de tri à la fin ce qu'il est, nous allons regarder de plus près.
Trier Bucket
L'idée de base
Phrase, chaque élément sera triée par fonction de mappage de colonne configuré attribué à un nombre limité de godets, chaque godet et ensuite trier les éléments.
Les étapes de base sont les suivantes:
- Un nombre limité de seau vide prêt
- Traversant la colonne à trier, affectés chacun à un élément correspondant dans la cuve par la fonction de mappage
- Chaque godet est vide ne sorte
- A partir de chaque godet est non vide, suivie par les éléments de nouveau dans la séquence d'origine
la cartographie fonction de tri du godet est réalisé en utilisant l'élément de division, l'étape de comparaison de l'échange est omis, une petite quantité de données est effectuée dans la cuve, le reclasser ici sélectionner l'un algorithme de tri en fonction des besoins réels, tels que l'utilisation d'un tri rapide. Notez que la fonction de sélection de carte doit veiller à ce que chaque cuve est commandé, à savoir, tous les éléments d'un seau doit être plus ou moins que tous les éléments d'un autre seau. De cette manière, afin de remettre la séquence d'origine de chaque élément dans le godet, pour assurer des éléments ordonnés.
La complexité et la stabilité des avantages et des inconvénients
-
la complexité de l'espace: O (m + n), m représente un nombre de compartiments, n est exprimée par la longueur requise de l'espace auxiliaire n
-
complexité du temps: O (n)
chronophages tri seau deux parties principales:- Tous les éléments seront triés colonne dans le seau, la complexité temporelle de O (n)
- Et trier chaque élément de barillet, car l'algorithme est basé sur la comparaison, la complexité temporelle moyenne ne peut atteindre O (N I connecte 2 N I ), N I est le nombre d'éléments dans chaque cuve
Pour les colonnes N à éléments triés, seaux M, chaque élément de moyenne seau N / M, qui Bucket sorte la complexité temporelle moyenne peut être exprimée comme suit:
O (n) + O (M * (N / M) log 2 (N / M) ), où M == N, la complexité est O (n) -
De préférence, les cas: O (n), lorsque la colonne de l'élément à trier est réparti uniformément dans la cuve, est un temps linéaire O (n). Chaque baril moins de données utilisées pour trier moins de temps, mais la consommation d'espace correspondant augmentera. Lorsque chaque godet un seul élément, à savoir, M == N, où le meilleur ordonnancement de la cuve, atteint un vrai O (n)
-
Le pire des cas: tous les éléments sont affectés au même seau, dégénérés de tri seau dans une sorte ordinaire.
-
Stabilité: Stable
-
Avantages: stable, brisant la limite inférieure basée sur la comparaison du genre
-
Inconvénients: le besoin d'espace de soutien supplémentaire a besoin bonne fonction de cartographie
algorithme
public void BucketSort(int[] array){
int max = array[0], min = array[0];
for(int i = 1; i < array.Length; i ++){
if(array[i] > max) max = array[i];
if(array[i] < min) min = array[i];
}
List<int>[] buckets = new List<int>[Fun(max, min, array.Length) + 1];
for(int i = 0; i < buckets.Length; i ++){
buckets[i] = new List<int>();
}
for(int i = 0; i < array.Length; i ++){
buckets[Fun(array[i], min, array.Length)].Add(array[i]);
}
int index = 0;
for(int i = 0; i < buckets.Length; i ++){
// 桶内的排序借助了Sort方法，也可以使用其他排序方法
buckets[i].Sort();
foreach(int item in buckets[i]){
array[index ++] = item;
}
}
}
// 映射函数，可以根据实际需求选择不同的映射函数
public int Fun(int value, int minValue, int length){
return (value - minValue) / length;
}
algorithme [interprétation]
Tout d' abord, afin de déterminer la fonction de mappage Fun, la valeur de retour de la fonction est l'élément correspondant au bain indice. Et puis trouver les valeurs maximales et minimales pour être colonne de tri et déterminer le nombre de seaux seau par type maximum et minimum. Traversant tous les éléments devant être triés par la fonction de mappage de colonne et de Funles affecter à la cuve d'indices correspondant. Et puis successivement pour trier tous les éléments pour chaque godet, est utilisé ici pour fournir la méthode C # Trier (sélection d'une méthode de tri différent). Lorsque les éléments d'un canon de tri, puis les remettre dans l'ordre d' origine.
[Pour] châtaignes
Pour une colonne à trier 4, 7, 1, 16, peut être utilisé à la figure 6 montrant le processus de tri du godet.:
compter Trier
L'idée de base
Compter tri peut être considéré comme une sorte de seau spécial de se rendre compte, si vous comprenez les mots sorte de seau, le comptage est relativement très simple tri.
Compter les exigences de séquençage de tous les éléments d'être triés colonne est dans l'intervalle [0, max] un entier positif (bien sûr après déformation peut être négatif, par exemple par addition d' une valeur, de sorte que tous les éléments deviennent positifs)
les étapes de base sont les suivantes:
- Obtenir la valeur maximale de la colonne à trier, construction (valeur maximale + 1) matrice de comptage C, peut être considéré (valeur maximale + 1) ème cylindre, mais le cylindre est plus stocké dans les éléments, mais chaque affiche des éléments nombre de fois
- Traversant la colonne à trier, compter le nombre de chaque élément apparaissant dans le tableau de comptage. Un élément i se produit, les endroits comptage est incrémentée, à savoir, C [i] est l'indice de position d'élément ++
- Traversal compte réseau, si le C [i]> 0, il indique qu'il y a un élément i, i attribués de façon séquentielle aux éléments présents dans la séquence d'origine
La complexité et la stabilité des avantages et des inconvénients
- la complexité de l' espace: O (k)
expliquer ici, pour compter le genre de complexité de l' espace, de nombreux articles en ligne sont marqués est O (n + k), en fait, ce genre et compter algorithme spécifique lié à un algorithme Ajouter la séquence de comptage de séquence finale obtenue à la séquence d' origine d' une séquence auxiliaire, sans modifier la séquence d' origine, de sorte que la complexité de l' espace est en O (n + k), l'algorithme décrit ci- dessus sans l'utilisation de séquences auxiliaires, modifiés directement, de sorte que l'espace la complexité est O (k). L'algorithme fournit quelques articles peu importe comment directement étiqueté O (n + k) la complexité de l' espace est évidemment très facile pour les lecteurs induire en erreur. - complexité du temps: O (n + k), k représente la valeur constante de l'élément le plus important dans la colonne à trier
- De préférence, où: O (n + k)
- Le pire des cas: O (n + k)
- Stabilité: Stable
- Avantages: stable et approprié pour un maximum d'une séquence d'entiers n'est pas très grande, brisant la limite inférieure est petit algorithme de tri par rapport basé sur la valeur de k
- Inconvénients: il est une condition sine qua non, la valeur k est grande, il faut beaucoup d'espace supplémentaire
algorithme
public void CountSort(int[] array){
int max = array[0];
for(int i = 0; i < array.Length; i ++){
if(array[i] > max) max = array[i];
}
int[] count = new int[max + 1];
for(int i = 0; i < array.Length; i ++){
count[array[i]] ++;
}
int index = 0;
for(int i = 0; i < count.Length; i ++){
while(count[i] -- > 0){
array[index ++] = i;
}
}
}
algorithme [interprétation]
Tout d'abord, la valeur maximale est obtenue peut voir que les éléments de la colonne à trier et comptés pour construire un réseau (valeur maximale + 1) de longueur. Chaque élément de la colonne à trier traversal, et par l'élément matrice de comptage indice est le nombre d'occurrences des éléments d'enregistrement. puis compter traverse matrice, si la position correspondant à la valeur cible est supérieur à 0 (correspondant à un petit nombre exprimé sur plusieurs éléments), puis il y a une valeur de l'élément et la taille du sujet. Les éléments sont ajoutés à la séquence d'origine. Étant donné que l'objectif est de petite à grande, les séquences correspondantes sont également obtenues dans l'ordre croissant.
[Pour] châtaignes
5 montrant la procédure peut être utilisée pour trier son compte pour une colonne à trier 1, 2, 3, 4, Fig.:
Trier Radix
L'idée de base
Radix est une sorte de ne pas comparer, mais pour atteindre triée par « distribution » et les deux processus « Collectionnez ».
En premier lieu , la mise en place des files d'attente de r colonnes sont numérotées de 0 ~ R-1, des éléments de colonne de base r à trier (par exemple décimale, alors r = 10), puis de suivre les éléments de la collection de règles d'attribution:
- La valeur du bit le moins significatif de la presse, le n-ième élément de r est attribué à ladite file d'attente, puis petit à des éléments généraux dans la file d'attente séquentiellement collectées
- Ensuite, la valeur des seconds bits les moins significatifs des éléments nouvellement recueillies de r sont attribuées à la file d'attente, alors recueilli
- Effectuer la distribution à plusieurs reprises décrit ci-dessus et de la collecte, jusqu'à ce que le bit le plus significatif. (Autrement dit, si le nombre de bits est d, d fois doivent être répétées, le nombre de bits d 'une mesure de l'élément maximal de l'ensemble des éléments, tels que si le nombre maximum est de 963, alors d = 3)
Pourquoi vous pouvez compléter le commander?
Dans les petites et grandes, par exemple, lorsque la première séquence en conformité avec le moins significatif de l' allocation et la désallocation, les bits obtenus à ce moment, l'élément repose sur les bits significatifs plus bas dans l' ordre croissant de la valeur.
Lorsque la distribution et la collecte d' un deuxième bit de poids faible en conformité avec le temps, la séquence obtenue est dans l' ordre croissant en fonction de la valeur de l' élément binaire suivant significative inférieure, puis dans l' ordre croissant en fonction de la valeur du bit le moins significatif.
Ainsi, lorsque le bit le plus significatif conformément à la répartition du temps final et la collecte, la séquence résultante est dans l' ordre croissant en fonction de la valeur du bit le plus significatif des éléments, encore disposés selon les bits les plus significatifs suivant. . . , Toujours selon le deuxième bit de poids le plus faible, puis sur la base du bit le moins significatif. Naturellement complété dans l' ordre croissant de chaque élément.
La complexité et la stabilité des avantages et des inconvénients
- la complexité de l'espace: O (n + r), r représente un élément de base, tel qu'un élément décimal, r = 10
- complexité du temps: O (d (n + r))
- Meilleur exemple: O (d (n + r))
- Le pire des cas: O (d (n + r))
- Stabilité: Stable
- Avantages: stable, la complexité de temps peut briser la limite inférieure basée sur une comparaison du type de
- Inconvénients: le besoin d'espace auxiliaire supplémentaire
algorithme
public void RadixSort(int[] array){
int max = GetMaxValue(array);
int[] buckets = new int[10];
int[] buffer = new int[array.Length];
for(int i = 1; max / i > 0; i = i * 10){
// 统计每个桶中的元素个数
for(int j = 0; j < array.Length; j ++){
buckets[array[j] / i % 10] ++;
}
// 使每个桶记录的数表示在buffer数组中的位置
for(int j = 1; j < buckets.Length; j ++){
buckets[j] += buckets[j - 1];
}
// 收集，将桶中的数据收集到buffer数组中
for(int j = array.Length - 1; j >= 0; j --){
buffer[-- buckets[array[j] / i % 10]] = array[j];
}
for(int j = 0; j < array.Length; j ++){
array[j] = buffer[j];
}
// 清空桶
for(int j = 0; j < buckets.Length; j ++){
buckets[j] = 0;
}
}
}
// 获得待排序列中的最大元素
public int GetMaxValue(int[] array){
int max = array[0];
for(int i = 1; i < array.Length; i ++){
if(array[i] > max){
max = array[i];
}
}
return max;
}
algorithme [interprétation]
Est un nombre décimal de l'algorithme, de sorte que R = 10
acquiert d' abord à trier le plus grand élément de la colonne, puis recueillies et d fois le nombre de bits alloué ; d plus grand élément de
distribution et de collecte au cours de chaque passe suit:
la donnée la valeur médiane est calculée pour chaque élément à trier sur la colonne en position, si un élément sans ce bit est représenté par 0. Ensuite , en utilisant une longueur du tableau seau de 10 enregistrer le nombre de fois où ils apparaissent (ici, la baignoire ne sert pas enregistrer directement l' élément correspondant). Puis de nouveau traversé tableau seau buckets[j] += buckets[j - 1];, de sorte que la valeur enregistrée dans chaque godet, est représenté sur le nombre de bits spécifié est égal à l'indice de godet de l'élément de tableau dans l'auxiliaire bufferposte.
Collection et ensuite, sur la base de l'information de position enregistrée dans le réseau de godet recueilli successivement à l' élément correspondant bufferde la matrice. Enfin vider le seau, la préparation de la prochaine mission de recueillir une fois.
[Pour] châtaignes
Pour une colonne à trier 9, 40, 123, 56, 7, 17 peuvent être utilisés à la figure la procédure de tri radix représente:
plus
Le code ci - dessus source de l' algorithme sont placés sur GitHub, les étudiants intéressés peuvent cliquer ici pour voir la
mise en œuvre sommaire et plus l' algorithme de code ( et pas seulement l'algorithme de tri), vous pouvez consulter le référentiel GitHub algorithme