Toi à bulles:
Il s'agit de comparer successivement deux éléments adjacents selon l'indice. S'ils sont supérieurs à / inférieurs à (selon qu'ils doivent être triés ascendant ou descendant), ils seront remplacés. Sinon, il n'y aura pas de changements de cette manière. Après avoir comparé les temps N-1, N est égal au nombre d'éléments; n-2, n-3 ... jusqu'au dernier tour, ils sont comparés une fois, donc le nombre de comparaisons diminue: de N-1 à 1
Alors le nombre total de comparaisons est: 1 + 2 + 3 + ... + (n-1), calculé par formule arithmétique: (1 + n-1) / 2 * (n-1) ==> n / 2 * (n-1) ==> (n ^ 2-n) * 0,5
La complexité temporelle de l'algorithme est exprimée par un grand o: o (n ^ 2), et le coefficient 0,5 et la constante -n sont ignorés.
classe publique Bubblesort {public static void main (String [] args) {int len = 10; int [] ary = new int [len]; Aléatoire aléatoire = nouveau aléatoire (); pour (int j = 0; j <len; j ++) {ary [j] = random.nextint (1000); } System.out.println ("----------------------"); pour (int j = 0; j <ary.length; j ++) {System.out.print (ary [j] + ""); } / * * Ordre ascendant, ASC1 et ASC2 optimiser le nombre de comparaisons de boucles internes, ce qui est une meilleure * comparaisons totales: * ASC1, ASC2: (1 + N-1) / 2 * (N-1) ==> N / 2 * (N-1) ==> N * (N-1) / 2 ==> (N ^ 2-N) / 2 * ASC: N ^ 2-N * / / / ORDREASC (ARY); // OrderAsc2 (ARY); OrderAsc1 (ARY); // Ordre descendant, juste besoin de remplacer la taille du jugement} statique void OrderAsC (int [] ary) {int count = 0; // Nombre de comparaisons int len = ary.length; pour (int j = 0; j <len; j ++) {// nombre de cycles fixes externes pour (int k = 0; k <len - 1; k ++) {// le nombre de boucles fixes internes if (ary [k]> ary [k + 1]) {ary [k] = ary [k + 1] + (ay-step Valeurs variables * a = a + b * b = ab * a = ab * /} count ++; }} System.out.println ("/ n ------ OrderAsC après tri dans l'ordre ascendant --------- Nombre de fois:" + Count); pour (int j = 0; j <len; j ++) {System.out.print (ary [j] + ""); }} static void OrderAsC1 (int [] ary) {int count = 0; // nombre de comparaison int len = ary.length; pour (int j = 0; j <len; j ++) {// nombre de boucles fixes en couche externe pour (int k = len - 1; k> j; k--) {// nombre de comparaisons dans la couche intérieure de plus à moins if (ary [k] <ary [k - 1]) {Ary [k] = ary [k - 1] + (ary [K - 1] 0; // Exchange en une étape} Count ++; }} System.out.println ("/ n --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (int J = 0; System.out.print (ary [j] + "");}} static void OrderAsc2 (int [] ary) {int count = 0; // des comparaisons int len = ary.length; = 0; k <j; k ++) {// Nombre de comparaisons diminuant de plus à moins dans la couche interne if (ary [k]> ary [k + 1] = ary [k]) * 0; // Ordre ------ Nombre de fois: "+ count); pour (int j = 0; j <len; j ++) {System.out.print (ary [j] +" ");}}}}Imprimer
-------Before sorting------ 898 7 862 286 879 660 433 724 316 737 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Sort de bulles bidirectionnel
Bubble tri_cocktail Le tri est le tri à bulles bidirectionnel.
La différence entre cet algorithme et le tri des bulles est que lors du tri, il est trié dans deux directions dans la séquence, et la couche externe compare les limites gauche et droite l <r,
Un cycle dans la couche intérieure est proportionnel de gauche à droite, et la valeur élevée est définie après; Un cycle est basé sur la droite à gauche, et la valeur basse est définie avant;
En termes d'efficacité, O (n ^ 2), n'est pas plus rapide que les bulles ordinaires
classe publique bubble_cocktailsort {public static void main (String [] args) {int len = 10; int [] ary = new int [len]; Aléatoire aléatoire = nouveau aléatoire (); pour (int j = 0; j <len; j ++) {ary [j] = random.nextint (1000); } / * * Le nombre minimum d'échanges est 1 fois, et le nombre maximum est (n ^ 2-n) / 2 fois * / // ary = new int [] {10,9,8,7,6,5,4,3,2,1}; // Testez le nombre d'échanges // ary = new int [] {1,2,3,4,5,6,7,8,10,9}; // Test Exchanges System.out.println ("---------------------------"); pour (int j = 0; j <ary.length; j ++) {System.out.print (ary [j] + ""); } OrderAsC1 (ARY); // OrderAsc2 (ARY); // en fonction de l'ordre, il suffit de remplacer la taille du jugement} statique void OrderAsc1 (int [] ary) {int compareCount = 0; // Comparez Times int ChangeCount = 0; // Nombre d'échanges int len = ary.length; int Left = 0, droite = len -1, tl, tr; tandis que (gauche <droite) {// le nombre de cycles fixes de la couche externe tl = gauche + 1; tr = droite - 1; pour (int k = gauche; k <droite; k ++) {// le nombre de comparaisons de la couche intérieure de plus à moins, de gauche à droite if (ary [k]> ary [k + 1]) {// le front est supérieur à l'arrière, substitut ary [k] = ary [k + 1] + (ay [k + 1] = aRy [k]) * 0; // le pascombre ++ dans un examen; tr = k; // L'indice où K est situé est donné à TR, et TR représente la valeur de l'indice final de la comparaison suivante, après avoir comparé de gauche à droite, K représente l'index à gauche} CompareCount ++; } droit = tr; pour (int k = droit; k> gauche; k--) {// Le nombre de comparaisons dans la couche intérieure est réduit de plus à moins, de droite à gauche if (ary [k] <ary [k - 1]) {// ce dernier est inférieur à la pré-permutation ary [k] = ary [k - 1] + (k - 1] =+; tl = k; // Dans la dernière comparaison dans un tour, attribuez l'index où K est situé à TL, TL représente la valeur de l'indice de départ de la comparaison suivante. Après avoir comparé de droite à gauche, K représente l'indice à droite} CompareCount ++; } Left = tl; } System.out.println ("/ n ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- pour (; l <r;) {// le nombre de cycles fixes extérieurs tl = l + 1; tr = r - 1; + 1]; ary [k - 1] = temp - ary [k - 1]; ary [k] = temp - ary [k - 1]; ChangeCount ++; tl = k; } CompareCount ++; } l = tl; } System.out.println ("/ n ----- OrderAsc2 après tri dans l'ordre ascendant ------- Nombre de comparaisons:" + CompareCount + ", échanges:" + changeCount); pour (int j = 0; j <len; j ++) {System.out.print (ary [j] + ""); }}}Imprimer
--------Before sorting------ 783 173 53 955 697 839 201 899 680 677 -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------