Tipo de bolha:
É comparar dois elementos adjacentes sucessivamente de acordo com o índice. Se forem maiores que/menores que (dependendo se precisam ser classificados ascendentes ou descendentes), serão substituídos. Caso contrário, não haverá alterações dessa maneira. Depois de comparar N-1 vezes, n é igual ao número de elementos; N-2, N-3 ... até a última rodada, eles são comparados uma vez, então o número de comparações está diminuindo: de N-1 para 1
Então o número total de comparações é: 1+2+3+...+(n-1), calculado por fórmula aritmética: (1+n-1)/2*(n-1) ==> n/2*(n-1) ==> (n^2-n)*0,5
A complexidade do tempo do algoritmo é expressa por O: O (n^2), e o coeficiente 0,5 e a constante -n são ignorados.
classe pública bubblesort {public static void main (string [] args) {int len = 10; int [] ary = new int [len]; Aleatório aleatório = novo aleatório (); for (int j = 0; j <len; j ++) {ary [j] = aleatom.nextInt (1000); } System.out.println ("---------------"); for (int j = 0; j <ary.length; j ++) {System.out.print (ary [j]+""); }/** Ordem ascendente, ASC1 e ASC2 otimizam o número de comparações de loops internos, o que é melhor* comparações totais:* ASC1, ASC2: (1+n-1)/2* (n-1) ==> n/2* (n-1) ==> n* (n-1)/2 ==> (n^2n)/2*; // Orderasc2 (ary); Orderasc1 (Ary); // Ordem descendente, só precisa substituir o tamanho do julgamento} estático void Orderasc (int [] ary) {int conting = 0; // número de comparações int len = ary.length; para (int j = 0; j <len; j ++) {// número de ciclos fixos externos para (int k = 0; k <len - 1; k ++) {// o número de loops fixo interno if (ary [k]> ary [k + 1]) {ary [k] = ary [k + 1] + (ARY [K + 1]) {ary [k] = [k + 1] + (ARY [K) Valores variáveis * a = a+b * b = ab * a = ab */} count ++; }} System.out.println ("/n ------ Orderasc após classificar em ordem crescente --------- Número de vezes:" + contagem); for (int j = 0; j <len; j ++) {System.out.print (ary [j]+""); }} estático void Orderasc1 (int [] ary) {int count = 0; // número de comparação int len = ary.length; for (int j = 0; j < len; j++) {//Number of fixed loops in outer layer for (int k = len - 1; k > j; k--) {//Number of comparisons in inner layer from more to less if (ary[k] < ary[k - 1]) { ary[k] = ary[k - 1] + (ary[k - 1] = ary[k]) * 0; // troca de um passo} count ++; } } System.out.println("/n------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (int j = 0; j < len; j++) { System.out.print (ary [j] + ""); = 0; Ordem ------ Número de vezes: " + contagem); para (int j = 0; j <len; j ++) {System.out.print (ary [j] +" ");}}}}Imprimir
------- Antes de classificar ------ 898 7 862 286 879 660 433 724 316 737 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Bolha de duas vias
Classificação Bubble STORNING_COCKLATION é a classificação de bolhas de mão dupla.
A diferença entre esse algoritmo e classificação de bolhas é que, ao classificar, ele é classificado em duas direções na sequência, e a camada externa compara os limites esquerdo e direito l <r,
Um ciclo na camada interna é proporcional da esquerda para a direita e o alto valor é definido após; Um ciclo é baseado na direita para a esquerda e o valor baixo é definido antes;
Em termos de eficiência, O (n^2), não é mais rápido que bolhas comuns
public class Bubble_cocktailsort {public static void main (string [] args) {int len = 10; int [] ary = new int [len]; Aleatório aleatório = novo aleatório (); for (int j = 0; j <len; j ++) {ary [j] = aleatom.nextInt (1000); }/** O número mínimo de trocas é 1 tempo e o número máximo é (n^2-n)/2 vezes*/// ary = new int [] {10,9,8,7,6,5,4,3,2,1}; // Teste o número de trocas // ary = new int [] {1,2,3,4,5,6,7,8,10,9}; // trocas de teste system.out.println ("---------------------------"); for (int j = 0; j <ary.length; j ++) {System.out.print (ary [j]+""); } orderasc1 (ary); // Orderasc2 (ary); // dependendo da ordem, só precisa substituir o tamanho do julgamento} estático void Orderasc1 (int [] ary) {int compareCount = 0; // Compare os tempos int chanGecount = 0; // número de trocas int len = ary.length; int esquerd = 0, direita = len -1, tl, tr; enquanto (esquerda <direita) {// o número de ciclos fixos da camada externa tl = esquerda + 1; tr = direita - 1; para (int k = esquerda; k <direita; k ++) {// o número de comparações da camada interna de mais a menos, da esquerda para a direita se (ary [k]> ary [k + 1]) {// a frente é maior que o traseiro, substituto [k] = ary [k + 1] + (ARY [k 1] tr = k; // O índice em que K está localizado é dado ao TR, e TR representa o valor do índice final da comparação subsequente, depois de comparar da esquerda para a direita, k representa o índice à esquerda} compareCount ++; } direita = tr; para (int k = direita; k> esquerda; k--) {// O número de comparações na camada interna é reduzido de mais para menos, da direita para a esquerda se (ary [k] <ary [k-1]) {// o último é menor que a pré-permutação ary [k] = ary [k kn-1] (ARY [k-k-k-k-k] = 1] = 1; tl = k; // Na última comparação em uma rodada, atribua o índice em que K está localizado para TL, TL representa o valor do índice inicial da comparação subsequente. Depois de comparar da direita para a esquerda, K representa o índice à direita} compareCount ++; } esquerda = tl; } System.out.println ("/n ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- para (; l <r;) {// o número de ciclos fixos externos tl = l + 1; ARY [K+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 Após classificar em ordem crescente ------- Número de comparações:" + compareCount + ", trocas:" + changeCount); for (int j = 0; j <len; j ++) {System.out.print (ary [j]+""); }}}Imprimir
--------Before sorting------ 783 173 53 955 697 839 201 899 680 677 -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------