Implementação de código Java da versão atualizada do Bubble Sort

• Cada rodada de classificação de bolha compara os elementos da esquerda para a direita e realiza a troca de elementos de um único item
• Se o menor elemento classificado em ordem crescente estiver no final e os elementos anteriores já estiverem classificados, nosso loop externo precisará percorrer n-1 vezes, o que resultará em muitas passagens inúteis e trocas de elementos
• Podemos percorrer os elementos trocados da esquerda para a direita e, em seguida, percorrer os elementos trocados da direita para a esquerda, semelhante a um pêndulo, até o elemento do meio, a classificação está completa
• Implementação Java de ordenação de coquetéis

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

• O algoritmo de coquetel pode reduzir o número de percursos de classificação sob condições específicas, mas a quantidade de código implementado dobrou e só pode aproveitar quando a maioria dos elementos já estiver em ordem