Le tri 1. Comparative
sorte comparatif est plus méthode de tri blanc évident, à partir du premier élément, et en comparant séquentiellement tous les éléments suivants, plus petit que le premier élément, ces deux éléments seront échangés, et enfin complété le premier rapport un premier élément doit être minimale, puis à partir du deuxième élément, les éléments et de toute comparaison ultérieure, un rapport de fini, le second élément est une seconde petite, empathie, que n-1 Fin (n est le nombre d'éléments de réseau) roue, tous devenus réseau ordonné. Tri comparative est stable , qui est, la valeur est rencontrée que l'échange ne se produit pas est grande, la position de maintien, sa complexité est en O (n ^ 2), le code suivant:
#include <iostream>
using namespace std;
void swap(int* a,int* b){//交换
int temp=*a;
*a=*b;
*b=temp;
}
void Sort(int a[],int len){
for(int i=0;i<len-1;i++){
for(int j=i+1;j<len;j++){
if(a[i]>a[j]){
swap(a[i],a[j]);
}
}
}
}
int main(){
int a[10]={8,6,9,7,3,0,2,5,1,4};
cout << "排序前的数组：" << endl;
for(int i=0;i<10;i++){
cout << a[i] << " ";
if(i==9) cout << endl;
}
Sort(a,10);
cout << "排序后的数组：" << endl;
for(int i=0;i<10;i++){
cout << a[i] << " ";
if(i==9) cout << endl;
}
return 0;
}
2. Bubble genre
Bubble est en quelque sorte un algorithme de tri est un classique, comme son nom l' indique, tri à bulles, il suffit de prendre les ampoules d'eau, comme la plupart se leva lentement sous le haut. Bubble éléments adjacents est sorte sont comparés, de sorte que la valeur maximale à la surface finale de changer lentement, de sorte que la bulle possède sorte à être n-1 fois, est stable , et sa complexité en temps est O (N ^ 2) , comme suit:
#include <iostream>
using namespace std;
void swap(int* a,int* b){//交换
int temp=*a;
*a=*b;
*b=temp;
}
void Sort(int a[],int len){
for(int i=0;i<len-1;i++){
for(int j=0;j<len-i-1;j++){
if(a[j]>a[j+1]){
swap(a[j],a[j+1]);
}
}
}
}
int main(){
int a[10]={8,6,9,7,3,0,2,5,1,4};
cout << "排序前的数组：" << endl;
for(int i=0;i<10;i++){
cout << a[i] << " ";
if(i==9) cout << endl;
}
Sort(a,10);
cout << "排序后的数组：" << endl;
for(int i=0;i<10;i++){
cout << a[i] << " ";
if(i==9) cout << endl;
}
return 0;
}
3. rapide Tri
rapide Tri rangée visée rapide, est la méthode la plus courante de tri, la bibliothèque STL C du procédé qui sort () est la ligne rapide (optimisé). COMPRENDRE tri rapide , vous devez d' abord comprendre la fracture idéologique et Conquer, est d'un grand problème complexe en petits problèmes faciles à résoudre, quand vous mettez tous les petits problèmes à résoudre, le gros problème sera résolu. Pour en revenir si décharge rapide, idée de décharge rapide est: trouver une valeur de référence à tableau trié, le tableau sera trié en deux sections, la première section de l'ensemble est inférieure à la valeur de la valeur de référence, l'ensemble est supérieure à la valeur du deuxième alinéa de cette valeur de référence . Cette opération est ensuite répétée jusqu'à ce que l'ensemble du réseau de ces sont devenus bon ordre. C'est « l'ensemble ordonnée, partielle désordre » . Dans lequel la vitesse de référence en rapport avec l'efficacité de la valeur de rangée sélectionnée, vidange rapide de la complexité moyenne de O (n * logn) lorsque le réseau est complètement inversée, dégénéré de ligne rapide en une complexité en O (n-2 ^) . Sélectionnez rapport à la valeur de référence (optimisation de la ligne rapide) ne se développe pas ici, nous choisissons généralement l'intervalle de l' élément le plus à gauche que la valeur de référence.
Donc , notre problème sur la façon dont le segment de gamme? Il est également rapide noyau de drainage: de balayage transversal, la position de l'élément de commutation
, par exemple: à matrice triée est: 8697302514
Dans ce cas, l'indicateur de valeur de référence = 8, la plus à gauche intervalle indice gauche = 0, la droite la plus à droite de l' indice = 9; droite-9 commence à partir de l'extrémité droite de balayage (valeur de référence parce que nous avons choisie est la plus à gauche valeur de l' élément), 4 < 8, le côté gauche doit être représentatif de 4 à 8, nous allons échanger sa position, la matrice devient: 4 6 9 7 3 0 2 5 1 8, gauche = 0, droite = 9 puis commence à partir de la gauche à balayage gauche = 0 ,, 4 <= 8, 4 doit être représentatif de la partie gauche 8, dans la position correcte, alors le prochain balayage, 6 <= 8, 6 doit être représentatif de la partie gauche 8, dans la position correcte, alors le balayage suivant, 9 => 8,9. 8 situé sur la droite doit être , j échange, la matrice devient: 4 6 8 7 3 0 2 5 1 9, gauche = 2, à droite = 9, puis répéter cette opération (pas d' échange continue vers l' avant (après) balayée par un autre échange sur lors de la numérisation de démarrage) jusqu'à ce que la gauche> = droite, il représente le tableau a été divisé en plusieurs segments. Le tableau est divisé en plusieurs parties: 4617302589, divisé en 46173025 à trier et les deux sections 9, opération ci - dessus est répété jusqu'à ce que toutes les sections sont triés ( la position de chaque élément sont correctement), qui est le tri est terminé. Notez que: décharge rapide est instable . Sur la base des idées ci - dessus, nous pouvons écrire le code suivant:
le code contient des notes détaillées comme suit :()
#include <iostream>
using namespace std;
void swap(int *a,int *b){//交换
int temp=*a;
*a=*b;
*b=temp;
}
int partition(int left,int right,int a[]){//使基准值左边全小于基准值，基准值右边全大于基准值
int flag=a[left];//基准值，一般选取区间最左边的元素
while(left<right){
//先从后往前扫，如果比基准值小，将两个值交换
while(left<right && a[right]>=flag) right--;
swap(&a[left],&a[right]);
//然后从前往后扫，如果比基准值大，将两个值交换
while(left<right && a[left]<=flag) left++;
swap(&a[left],&a[right]);
}
return left;//返回基准值的下标，以此为分界线，将区间划分成两个小区间
}
void quickSort(int start,int end,int a[]){//递归调用（分治思想），直至所有的元素
if(start<end){
int flag=partition(start,end,a);
quickSort(start,flag-1,a);
quickSort(flag+1,end,a);
}
}
int main(){
int a[10]={8,6,9,7,3,0,2,5,1,4};
cout << "排序前的数组：" << endl;
for(int i=0;i<10;i++){
cout << a[i] << " ";
if(i==9) cout << endl;
}
quickSort(0,9,a);
cout << "排序后的数组：" << endl;
for(int i=0;i<10;i++){
cout << a[i] << " ";
if(i==9) cout << endl;
}
return 0;
}
