Sorteo de burbujas:
Es para comparar dos elementos adyacentes sucesivamente según el índice. Si son mayores/menos que (dependiendo de si deben clasificarse ascendiendo o descender), serán reemplazados. De lo contrario, no habrá cambios de esta manera. Después de comparar N-1 Times, N es igual al número de elementos; N-2, N-3 ... Hasta la última ronda, se comparan una vez, por lo que el número de comparaciones está disminuyendo: de N-1 a 1
Entonces el número total de comparaciones es: 1+2+3+...+(N-1), calculado por la fórmula aritmética: (1+N-1)/2*(N-1) ==> N/2*(N-1) ==> (N^2-N)*0.5
La complejidad del tiempo del algoritmo se expresa por O: O (N^2), y se ignoran el coeficiente 0.5 y la constante -N.
public class Bubblesort {public static void main (string [] args) {int len = 10; int [] ary = new int [len]; Aleatorio aleatorio = new Random (); for (int j = 0; j <len; j ++) {ary [j] = random.nextint (1000); } System.out.println ("-----------------"); for (int j = 0; j <ary.length; j ++) {system.out.print (ary [j]+""); }/** Orden ascendente, ASC1 y ASC2 optimizan el número de comparaciones de los bucles internos, que es mejor* comparaciones totales:* ASC1, ASC2: (1+N-1)/2* (n-1) ==> N/2* (n-1) ==> n* (n-1)/2 ==> (n^2-n)/2* ASC: n^2n*/// ordersc (ary); // Orderasc2 (Ary); Orderasc1 (Ary); // orden descendente, solo necesita reemplazar el tamaño del juicio} static void orderasc (int [] ary) {int count = 0; // número de comparaciones int len = ary.length; para (int j = 0; j <len; j ++) {// número de ciclos fijos externos para (int k = 0; k <len - 1; k ++) {// el número de bucles internos fijos if (ary [k]> ary [k + 1]) {ary [k] = ary [k + 1] + (ary [k + 1] = ary [k]) * 0; valores variables * a = a+b * b = ab * a = ab */} count ++; }} System.out.println ("/N ------ Orderasc después de ordenar en orden ascendente --------- Número de veces:" + Count); para (int j = 0; j <len; j ++) {system.out.print (ary [j]+""); }} static void orderasc1 (int [] ary) {int count = 0; // número de comparación int len = ary.length; para (int j = 0; j <len; j ++) {// número de bucles fijos en capa externa para (int k = len - 1; k> j; k--) {// número de comparaciones en la capa interna de más a menos if (ary [k] <ary [k - 1]) {ary [k] = ary [k - 1]+(ary [k - 1] = ary [k] *) 0; // intercambio de un solo paso} count ++; }} System.out.println ("/N ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0; J = 0; System.out.print (ary [j] + ""); = 0; Orden ------ Número de veces: " + Count); para (int j = 0; j <len; j ++) {system.out.print (ary [j] +" ");}}}Imprimir
-------Before sorting------ 898 7 862 286 879 660 433 724 316 737 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Clasificación de burbujas de dos vías
La clasificación de burbujas Sorting_Cocktail es una clasificación de burbujas de dos vías.
La diferencia entre este algoritmo y la clasificación de burbujas es que cuando se clasifica, se clasifica en dos direcciones en la secuencia, y la capa externa compara los límites izquierdo y derecho l <r,
Un ciclo en la capa interna es proporcional de izquierda a derecha, y el valor alto se establece después; Un ciclo se basa en la derecha a la izquierda, y el valor bajo se establece antes;
En términos de eficiencia, o (n^2), no es más rápido que las burbujas ordinarias
clase pública bubble_cocktailsort {public static void main (string [] args) {int len = 10; int [] ary = new int [len]; Aleatorio aleatorio = new Random (); for (int j = 0; j <len; j ++) {ary [j] = random.nextint (1000); }/** El número mínimo de intercambios es 1 vez, y el número máximo es (n^2-n)/2 veces*/// ary = new int [] {10,9,8,7,6,5,4,3,2,1}; // prueba el número de intercambios // ary = new int [] {1,2,3,4,5,6,7,8,10,9}; // Test Exchanges System.out.println ("---------------------------"); for (int j = 0; j <ary.length; j ++) {system.out.print (ary [j]+""); } Orderasc1 (ary); // Orderasc2 (Ary); // Dependiendo del orden, solo necesita reemplazar el tamaño del juicio} static void orderasc1 (int [] ary) {int comparecount = 0; // Compare Times int ChangeCount = 0; // Número de intercambios int Len = ary.length; int izquierdo = 0, derecho = len -1, tl, tr; while (izquierdo <derecho) {// El número de ciclos fijos de la capa externa tl = izquierda + 1; tr = derecho - 1; para (int k = izquierda; k <right; k ++) {// El número de comparaciones de la capa interna de más a menos, de izquierda a derecha if (ary [k]> ary [k + 1]) {// El frente es mayor que el retroceso, el sustituto [k] = ary [k + 1] + (ary [k + 1] = ary [k]) * 0; // el sustitute de los change. tr = k; // El índice donde se ubica k se da a TR, y TR representa el valor del índice final de la comparación posterior, después de compararse de izquierda a derecha, K representa el índice en la comparación de comparación izquierda} ++; } correcto = tr; for (int k = right; k > left; k--) {//The number of comparisons in the inner layer is reduced from more to less, from right to left if (ary[k] < ary[k - 1]) {//The latter is less than the pre-permutation ary[k] = ary[k - 1] + (ary[k - 1] = ary[k]) * 0;//One-step exchange ChangeCount ++; tl = k; // En la última comparación en una ronda, asigne el índice donde K se encuentra a TL, TL representa el valor de índice inicial de la comparación posterior. Después de compararse de derecha a izquierda, K representa el índice en la derecha} comparación ++; } izquierda = tl; } System.out.println ("/n ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- para (; l <r;) {// El número de ciclos fijos externos tl = l + 1; ary [k+1]; 1]; ary [k - 1] = temp - ary [k - 1]; ary [k] = temp - ary [k - 1]; ChangeCount ++; tl = k; } comparación ++; } l = tl; } System.out.println ("/n ----- OrderAsC2 después de clasificar en orden ascendente ------- Número de comparaciones:" + CompareCount + ", intercambios:" + ChangeCount); para (int j = 0; j <len; j ++) {system.out.print (ary [j]+""); }}}Imprimir
-------- antes de clasificar ------ 783 173 53 955 697 839 201 899 680 677 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------