冒泡排序及优化

冒泡排序及优化详解

算法思想：冒泡排序属于一种典型的交换排序。

交换排序顾名思义就是通过元素的两两比较，判断是否符合要求，如果不符合就交换位置来达到排序的目的。冒泡排序名字的由来就是因为在交换过程中，类似水冒泡，小（大）的元素经过不断的交换由水底慢慢的浮到水的顶端。#
　　
　　冒泡排序的思想就是利用的比较交换，利用循环将第 i 个小或者大的元素归位，归位操作利用的是对 n 个元素中相邻的两个进行比较，如果顺序正确就不交换，如果顺序错误就进行位置的交换。通过重复的循环访问数组，直到没有可以交换的元素，那么整个排序就已经完成了。

  /**
   * @author 
   * 冒泡排序常规版
   */
  public class BubbleSortNormal {
      public static void main(String[] args) {
          int[] list = {3,4,1,5,2};
          int temp = 0; // 开辟一个临时空间, 存放交换的中间值
          // 要遍历的次数
         for (int i = 0; i < list.length-1; i++) {
             System.out.format("第 %d 遍：\n", i+1);
             //依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上
             for (int j = 0; j < list.length-1-i; j++) {
                 // 比较相邻的元素，如果前面的数小于后面的数，就交换
                 if (list[j] < list[j+1]) {
                     temp = list[j+1];
                     list[j+1] = list[j];
                     list[j] = temp;
                 }
                 System.out.format("第 %d 遍的第%d 次交换：", i+1,j+1);
                 for(int count:list) {
                     System.out.print(count);                 }
                 System.out.println("");
             }
             System.out.format("第 %d 遍最终结果：", i+1);
             for(int count:list) {
                 System.out.print(count);
             }
             System.out.println("\n#########################");
         }
     }
 }

算法的第一次优化#
首先针对第一个问题，当我们进行完某一次排序的时候，实际上整个排序就已经完成了，但是常规版还是会继续排序。
　　比如数组是，5，4，3，1，2 的时候的时候就非常明显了，实际上在第一次循环的时候整个数组就已经完成排序，但是常规版的算法仍然会继续后面的流程，这就是多余的了。
　　为了解决这个问题，我们可以设置一个标志位，用来表示当前第 i 趟是否有交换，如果有则要进行 i+1 趟，如果没有，则说明当前数组已经完成排序。实现代码如下：

 /**
   * @author 
   * 冒泡排序优化第一版
   */
  public class BubbleSoerOpt1 {
      public static void main(String[] args) {
          int[] list = {5,4,3,1,2};
          int temp = 0; // 开辟一个临时空间, 存放交换的中间值
          // 要遍历的次数
         for (int i = 0; i < list.length-1; i++) {
             int flag = 1; //设置一个标志位
             //依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上
            for (int j = 0; j < list.length-1-i; j++) {
                 // 比较相邻的元素，如果前面的数小于后面的数，交换
                 if (list[j] < list[j+1]) {
                     temp = list[j+1];
                     list[j+1] = list[j];
                     list[j] = temp;
                     flag = 0;  //发生交换，标志位置0
                 }
             }
             System.out.format("第 %d 遍最终结果：", i+1);
             for(int count:list) {
                 System.out.print(count);
             }
             System.out.println("");     
             if (flag == 1) {//如果没有交换过元素，则已经有序
                 return;
             }
                    
         }
     }
 }

算法的第二次优化#
　　　优化一仅仅适用于连片有序而整体无序的数据(例如：1， 2，3 ，4 ，7，6，5)。但是对于前面大部分是无序而后边小半部分有序的数据(1，2，5，7，4，3，6，8，9，10)排序效率也不可观，对于种类型数据，我们可以继续优化。既我们可以记下最后一次交换的位置，后边没有交换，必然是有序的，然后下一次排序从第一个比较到上次记录的位置结束即可。

 /**
   * @author
   * 冒泡排序优化第二版
   */
  public class BubbleSoerOpt2 {
      public static void main(String[] args) {
          int[] list = {6,4,7,5,1,3,2};
          int len = list.length-1;
          int temp = 0; // 开辟一个临时空间, 存放交换的中间值
         int tempPostion = 0;  // 记录最后一次交换的位置
         // 要遍历的次数
         for (int i = 0; i < list.length-1; i++) {
             int flag = 1; //设置一个标志位
             //依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上
             for (int j = 0; j < len; j++) {
                 // 比较相邻的元素，如果前面的数小于后面的数，交换
                 if (list[j] < list[j+1]) {
                     temp = list[j+1];
                     list[j+1] = list[j];
                     list[j] = temp;
                     flag = 0;  //发生交换，标志位置0
                    tempPostion = j;  //记录交换的位置
                 }
                 System.out.format("第 %d 遍第%d 趟结果：", i+1, j+1);
                 for(int count:list) {
                     System.out.print(count);
                 }
                 System.out.println("");     
             }
             len = tempPostion; //把最后一次交换的位置给len，来缩减内循环的次数
             System.out.format("第 %d 遍最终结果：", i+1);
             for(int count:list) {
                 System.out.print(count);
             }
             System.out.println("");     
             if (flag == 1) {//如果没有交换过元素，则已经有序
                 return;
             }
                    
         }
     }
 }

总结：
冒泡排序的优化：
1、增加标志位 flag=0 ，没有做交换则 flag=1，判断当flag=1 时，跳出循环；
2、增加交换结束位 pos=0，用来记录最后一次交换的位置，并 pos = j，记录最后一次交换的位置，然后将 len = pos， 把最后一次交换的位置给len，来缩减内循环的次数