Princípio: compare dois elementos adjacentes e troca com grandes valores com a extremidade direita.
Ideia: Compare dois números adjacentes em sequência, coloque os decimais na frente e os grandes números na parte de trás. Ou seja, na primeira viagem: primeiro compare o primeiro e o segundo número, coloque o decimal antes e os grandes números depois. Em seguida, compare o segundo número e o terceiro número, coloque o decimal antes e depois do grande número, continue assim até que os dois últimos números sejam comparados, coloque o decimal antes e depois do grande número. Repita a primeira etapa até que toda a classificação esteja concluída.
Por exemplo: para classificar a matriz: int [] arr = {6,3,8,2,9,1};
Primeira ordem:
Primeira classificação: 6 e 3 Compare, 6 é maior que 3, posição de troca: 368291
Segunda classificação: 6 e 8 Compare, 6 é menor que 8, sem posição de troca: 368291
A terceira ordem: 8 e 2 Compare, 8 é maior que 2, posição de troca: 362891
Quarta Ordem: 8 e 9 Compare, 8 é menor que 9, sem posição de troca: 362891
Quinta Ordem: 9 e 1 Compare: 9 é maior que 1, posição de troca: 362819
A primeira viagem foi comparada no total 5 vezes, classificando resultados: 362819
-----------------------------------------------------------------------
Segunda Ordem:
Primeira classificação: 3 e 6 Compare, 3 é menor que 6, sem posição de troca: 362819
Segunda classificação: 6 e 2 Compare, 6 é maior que 2, posição de troca: 326819
A terceira ordem: 6 e 8 Compare, 6 é maior que 8, sem posição de troca: 326819
Quarta Ordem: 8 e 1 Compare, 8 é maior que 1, posição de troca: 326189
A segunda viagem foi comparada no total, e o resultado de classificação foi: 326189
-----------------------------------------------------------------------
A terceira ordem:
Primeira classificação: 3 e 2 Compare, 3 é maior que 2, posição de troca: 236189
Segunda classificação: 3 e 6 Compare, 3 é menor que 6, sem posição de troca: 236189
A terceira ordem: 6 e 1 Compare, 6 é maior que 1, posição de troca: 231689
A segunda viagem foi comparada no total, e o resultado de classificação foi: 231689
-----------------------------------------------------------------------
A quarta ordem:
Primeira classificação: 2 e 3 Compare, 2 é menor que 3, sem posição de troca: 231689
Segunda classificação: 3 e 1 Compare, 3 é maior que 1, posição de troca: 213689
A segunda viagem foi comparada no total, e o resultado de classificação foi: 213689
-----------------------------------------------------------------------
A quinta ordem:
Primeira classificação: 2 e 1 Compare, 2 é maior que 1, posição de troca: 123689
A segunda viagem foi comparada no total, e o resultado de classificação foi: 123689
-----------------------------------------------------------------------
Resultado final: 123689
-----------------------------------------------------------------------
A partir disso, podemos ver que N números precisam ser classificados e os N-1 vezes são classificados no total. O número de tempos de classificação para cada i-pass é (ni), para que você possa usar uma declaração de loop duplo para controlar quantas vezes a camada externa controlará o número de vezes para cada viagem, ou seja,
for (int i = 1; i <arr.length-1; i ++) {for (int j = 1; j <arr.length-1-i; j ++) {// Posição de troca}Vantagens da classificação de bolhas: toda vez que você classifica, você compara menos, porque toda vez que você classifica, você encontrará um valor maior. Como mencionado acima: após a primeira comparação, o último número deve ser o maior número. Ao classificar a segunda vez, você só precisa comparar outros números que não o último número e também pode descobrir que o maior número é classificado após o número que participa da segunda comparação. Ao comparar a terceira vez, você só precisa comparar outros números que não os dois últimos números, e assim por diante ... em outras palavras, se você não executar uma comparação, cada vez que comparar uma vez, o que reduz a quantidade do algoritmo em certa medida.
Em termos de complexidade do tempo:
1. Se nossos dados estiverem em ordem, precisamos apenas fazer uma viagem para concluir a classificação. O número necessário de comparações e movimentos de registro são o valor mínimo, ou seja: cmin = n-1; mmin = 0; Portanto, a melhor complexidade do tempo para a classificação de bolhas é O (n).
2. Se, infelizmente, nossos dados forem a ordem inversa, a ordem N-1 será necessária. Cada pedido deve ser comparado (1≤i≤n-1) e cada comparação deve ser movida para o registro três vezes para atingir a posição do registro de troca. Nesse caso, os tempos de comparação e movimento atingem o máximo: a pior complexidade do tempo do tipo de bolha é: O (n2).
Para resumir: a complexidade média total do tempo da espécie de bolha é: O (n2).
Implementação de código:
/ * * Class de bolha */classe pública bubblesort {public static void main (string [] args) {int [] arr = {6,3,8,2,9,1}; System.out.println ("A matriz antes de classificar é:"); para (int num: arr) {System.out.print (num+""); } para (int i = 1; i <arn.length; i ++) {// O loop externo controla o número de tempos de classificação para (int j = 1; j <arn.length-i; j ++) {// o loop interno controla quantas vezes é classificado se (j-1]> [j]) {Int TEMT = ARR = INT; arr [j] = arr [j-1]; arr [j-1] = temp; }}} System.out.println (); System.out.println ("A matriz classificada é:"); para (int num: arr) {System.out.print (num+""); }}}