Implementação java do algoritmo de classificação de bolhas

• Recentemente, li muitos livros e postagens de blog relacionadas a algoritmos e queria gravá-los sozinho. Aprendi classificação de bolhas na faculdade e quase esqueci agora. Vamos revisá-lo novamente hoje.

O que é algoritmo Bubble Sort?

• Bubble Sort (Bubble Sort) é a classificação de troca mais básica
• Ideia de classificação: compare elementos adjacentes para decidir se deve trocar posições
• O tipo de bolha original é um tipo estável e a complexidade de tempo é O(N^2)

Implementação Java do tipo de bolha

• A implementação original do Java de classificação por bolhas é a seguinte

  public class Test {
      public static void main(String[] args) {
          int[] a = {6, 4, 5, 3, 2, 1};
          bubbleSort(a);
          System.out.println("sort:" + Arrays.toString(a));
      }
  
      /**
       * 原始的冒泡升序排序
       *
       * @param array
       */
      public static void bubbleSort(int array[]) {
          int temp;//交换元素的临时变量
          for (int i = 0; i < array.length - 1; i++) {//外层循环遍历的次数array.length - 1
              for (int j = 0; j < array.length - (i + 1); j++) {//内层循环遍历相邻元素进行比较和交换
                  if (array[j] > array[j + 1]) {//相邻的前一个元素大于后一个元素则交换
                      temp = array[j];
                      array[j] = array[j + 1];
                      array[j + 1] = temp;
                  }
              }
          }
      }
  }
  

Otimização de classificação de bolhas

• A implementação original do tipo de bolha é muito simples, relativamente estável e a complexidade do tempo é basicamente inalterada
• Se for uma matriz ordenada para classificar, também levará o mesmo tempo
• O meio da classificação já está em ordem, então não precisamos percorrê-lo
• Se não trocarmos elementos depois de percorrer uma vez, sairemos do loop diretamente e a classificação estará completa
• Se no processo de percorrer elementos adjacentes, algumas das matrizes já estiverem em ordem, não precisamos percorrer os seguintes elementos
• Durante o processo de passagem, registramos o subscrito da última troca de elemento (esse subscrito é o limite entre a área ordenada e a área não ordenada) e o limite do próximo ciclo é o subscrito do último elemento trocado na última vez
• A implementação otimizada do Java de ordenação de bolhas é a seguinte:

  public class Test {
      public static void main(String[] args) {
          int[] a = {2, 11, 10, 3, 9, 2, 6, 4, 5, 3, 2, 1};
          bubbleSort(a);
          System.out.println("sort:" + Arrays.toString(a));
      }
  
      /**
       * 优化后的冒泡升序排序
       *
       * @param array
       */
      public static void bubbleSort(int array[]) {
          int temp;//交换元素的临时变量
          int boundary = array.length - 1;//无序区的边界，每次比较元素到这里
          for (int i = 0; i < array.length - 1; i++) {//外层循环遍历的次数array.length - 1
              boolean sorted = true;//有序标记，每一轮都设置为true
              int lastExchange = 0;//最后一次交换元素的位置
              for (int j = 0; j < boundary; j++) {//内层循环遍历相邻元素进行比较和交换
                  if (array[j] > array[j + 1]) {//相邻的前一个元素大于后一个元素则交换
                      temp = array[j];
                      array[j] = array[j + 1];
                      array[j + 1] = temp;
                      sorted = false;//有元素交换，设置排序完成为false
                      lastExchange = j;//有元素交换，记录下交换的下标
                  }
              }
  
              boundary = lastExchange;//最后一次交换元素的下标就是下次遍历的边界
              if (sorted) {//排序完成
                  break;
              }
          }
      }
  }