漫画算法-学习笔记（13）

漫画算法-小灰的算法之旅（13）

1. 什么是冒泡排序

什么是冒泡排序？

冒泡排序（bubble sort）:是一种基础的交换排序。冒泡排序的思想：把相邻的元素两两比较，当一个元素大于右侧相邻元素时，交换它们的位置；当一个元素小于或等于右侧相邻元素时，位置不变。

冒泡排序：是一种稳定排序，值相等的元素并不会打乱原本的顺序。由于改排序算法的每一轮都要遍历所有元素，总共遍历（元素数量-1）轮，因此平均时间复杂度是O(n^2).

示例如下：

有八个数字组成的一个无序数列{5,8,6,3,9,2,1,7},希望按照从小到大的顺序对其进行排序，按照冒泡排序的思想，我们把相邻的元素两两比较，当一个元素大于右侧相邻元素时，交换它们的位置，当一个元素小于或等于右侧相邻元素时，位置不变。经过第一轮排序，数列最右侧元素9的位置可以认为是一个有序区域，目前有序区域只有一个元素。

继续进行第二轮排序，

第二轮排序后，数列右侧的有序区域，有了两个元素。

继续执行排序操作，直到所有元素都是有序的为止。

冒泡排序代码实现

// 双重for循环
public static void sort( int array[]){
  
  for(int i=0;i<array.length-1;i++){
    
    for(int j=0;j<array.length-i-1;j++){
      
      int temp=0;
      //  比较两个元素大小，如果左侧元素大于右侧元素，则换位
      if(array[j]>array[j+1]){
        temp=array[j];
        array[j]=array[j+1];
        array[j+1]=temp;
      }
    }
  }
}

冒泡排序的优化

新增一个判断数列有序的标记。

public static void sort(int array[]){
  
  for(int i=0;i<array.length-1;i++){
    // 有序标记，每一轮的初始值都是true
    boolean isSorted =true;
    for(int j=0;j<array.length-i-1;j++){
      int temp=0;
      if(array[j]>array[j+1]){
        temp=array[j];
        array[j]=array[j+1];
        array[j+1]=temp;
        // 因为有元素进行交换，所以不是有序的，标记变为false
        isSorted=false;
      }
    }
    if(isSorted){
      break;
    }
  }
}

public static void main(String[] args){
  int[] array=new int[]{5,8,6,3,9,2,1,7};
  sort(array);
  System.out.println(Array.toString(array));
}

为了说明问题，这次以一个新的数列为例。这个数列的特点是前半部分的元素（3，4，2，1）无序，后半部分的元素（5，6，7，8）按升序排列，并且后半部分元素中的最小值也大于前半部分元素的最大值。

下面按照冒泡排序的思路进行排序：

第一轮

元素4和5比较，发现4小于5，所以位置不变；元素5和6比较，发现5小于6，所以位置不变；元素6和7比较，发现6小于7，所以位置不变；元素7和8比较，发现7小于8，所以位置不变。第一轮结束，数列中有序区域包含一个元素。

第二轮

元素3和2比较，发现3大于2，所以3和2交换；元素3和4比较，发现3小于4，所以位置不变。

元素4和5比较，发现4小于5，所以位置不变。

元素5和6比较，发现5小于6，所以位置不变。

元素6和7比较，发现6小于7，所以位置不变。

元素7和8比较，发现7小于8，所以位置不变。

第二轮结束，有序区域包含2个元素。

其实，右边的许多元素已经是有序的了，但每次轮训依旧比较了多次，因此如果有效的鉴定数列有序区的界定。那么就可以起到优化算法的目的。

算法优化： 新增一个标记，用来记录下最后一次元素交换的位置，该位置即为无序数列的边界，再往后的就是有序数列了。

public static void sort(int array[]){
  
  //记录最后一次交换的位置，
  int lastExchangeIndex=0;
  //无序数列的边界，每次比较只需要比到这里为止
  int sortBorder =array.length-1;
  for( int i=0;i<array.length-1;i++){
    //有序标记，每一轮的初始值都为true
    
    boolean isSorted=true;
    for(int j=0;j<sortBorder;j++){
      int temp=0;
      if(array[j]>array[j+1]){
        temp=array[j];
        array[j]=array[j+1];
        array[j+1]=temp;
        //因为有元素进行交换，所以不是有序的，标记变为false;
        isSorted=false;
        //更新为最后一次交换元素的位置
        lastExchangeIndex=j;
      }
    }
    sortBorder=lastExchangeIndex;
    if(isSorted){
      break;
    }
  }
}

public static void main(String[] args){
  
  int[] array=new int[]{3,4,2,1,5,6,7,8}
  sort(array);
  System.out.println(Arrays.toString(array));
}

sortBorder就是无序数列的边界。在每一轮排序过程中，处于sortBorder之后的元素就不需要再进行比较了，肯定是有序的。

2. 鸡尾酒排序

冒泡排序的每一个元素都可以像小气泡一样，根据自身大小，一点一点的向着数组的一侧移动。算法的每一轮都是从左到右来比较元素，进行单向的位置交换的。

那么鸡尾酒排序做了怎样的优化呢？

鸡尾酒排序的元素比较和交换过程是双向的。

由八个数字组成一个无序数列{2,3,4,5,6,7,8,1}，希望对其进行从小到大的排序。

如果按照冒泡排序的思想，排序过程如下。

那鸡尾酒排序是什么样子的呢？让我们来看一下详细过程。

第一轮（和冒泡排序一样，8和1交换）

第二轮

此时开始不一样了，我们反过来从右往左比较并进行交换。

第三轮(虽然实际上已经有序，但是流程并没有结束)

在鸡尾酒排序的第三轮，需要重新从左边向右比较并进行交换。

1和2比较，位置不变，2和3比较，位置不变，3和4比较，位置不变…

没有元素位置进行交换，证明已经有序，排序结束。

鸡尾酒排序的思路：排序过程像钟摆一样，第一轮从左到右，第二轮从右到左，第三轮再从左到右，依次交替交换。指导数组有序位置。

代码实现

public static void sort(int array[]){
  int temp=0;
  for(int i=0;i<array.length/2;i++){
    //有序标记，每一轮的初始值都是true
    boolean isSorted=true;
    //奇数轮，从左到右比较和交换，
    for(int j=i;j<array.length-i-1;j++){
      if(array[j]>array[j+1]){
        temp=array[j];
        array[j]=array[j+1];
        array[j+1]=temp;
        //有元素交换，所以不是有序的，标记为false
        isSorted=false;
      }
    }
    if(isSorted){
      break;
    }
    //在进入偶数轮之前，将isSorted重新标记为true
    
    isSorted=true;
    //偶数轮，从右到左比较和交换
    for(int j=array.length-i-1;j>i;j--){
      if(array[j]<array[j-1]){
        temp=array[j];
        array[j]=array[j-1];
        array[j-1]=temp;
        //因为有元素交换，所以不是有序数列，标记变为false
        isSorted=false;
      }
    }
    if(isSorted){
      break;
    }
  }
}

public static void main(String[] args){
  int[] array=new int[]{2,3,4,5,6,7,8,1};
  sort(array);
  System.out.println(Arrays.toString(array));
}

这段代码是鸡尾酒排序的原始实现，代码外层的大循环控制着所有排序回合，大循环内包含2个小循环，第一个小循环从左向右比较并交换数据，第二个小循环从右向左比较并交换元素。

3. 总结

鸡尾酒排序的优缺点是什么？

鸡尾酒排序的优点是能够在特定条件下，减少排序的回合数；

缺点也很明显，就是代码量几乎增加了1倍。

至于它能发挥优势的场景：是大部分元素已经有序的情况。