冒泡排序及优化

​
普通冒泡排序（以升序为例）：

• 依此比较数组中相邻两个元素大小，若a[j]>a[j+1]，则交换两个元素，两两都比较一遍称为一轮冒泡，结果是让最大的元素排至最后
• 重复以上步骤，直到整个数组有序

import java.util.Arrays;

public class Task01_BobbleSort {

    public static void main(String[] args) {
        int[] a = {5, 9, 7, 4, 1, 3, 2, 8};
//        int[] a = {1, 2, 3, 4, 5, 6, 7, 8};
        bubble(a);
    }

    public static void bubble(int[] a) {
        for (int j = 0;j < a.length-1;j++) {
            // 一轮冒泡
            for (int i = 0; i < a.length - 1 - j; i++) {
                if (a[i] > a[i + 1]) {
                    swap(a, i, i + 1);
                }
            }
            System.out.println("第"+j+"轮冒泡"+Arrays.toString(a));
        }
    }

    public static void swap(int[] a,int i,int j) {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

优化：

1. 可以设置一个标志位，记录每一次排序是否发生了交换，没有交换表示数组已经有序了

public static void bubble(int[] a) {                            
    for (int j = 0;j < a.length-1;j++) {                        
        // 一轮冒泡                                                 
        boolean swapped = false; // 是否发生交换                      
        for (int i = 0; i < a.length - 1 - j; i++) {            
            if (a[i] > a[i + 1]) {                              
                swap(a, i, i + 1);                              
                swapped = true;                                 
            }                                                   
        }                                                       
        System.out.println("第"+j+"轮冒泡"+Arrays.toString(a));     
        if (!swapped){                                          
            break;                                              
        }                                                       
    }                                                           
}                                                   

2. 记录上一次最后交换的位置，作为下一次循环的结束边界。如果最后一次交换的位置是0，说明已经排序成功，退出循环。

public static void bubble2(int[] a) {                     
    int n = a.length - 1;                                 
    while (true) {                                        
        int last = 0;  // 表示最后一次交换索引位置                    
        for (int i = 0; i < n; i++) {                     
              System.out.println("比较次数"+i);               
           if (a[i] > a[i + 1]) {                         
               swap(a, i, i + 1);                         
               last = i;                                  
            }                                             
        }                                                 
        System.out.println(Arrays.toString(a));           
        n = last;                                         
        if (n == 0){                                      
            break;                                        
        }                                                 
    }                                                     
}                                                         

​