數據結構之冒泡排序

排序思路：整個算法從最下面的元素開始，對相鄰的元素進行比較，經過交換使得較小的元素在較大的元素之上，經過對每個元素的兩兩比較，最后最小的元素被移到前面的位置。

算法實現：

public class BubbleSort {
    public static void bubbleSort(int arr[]){
        int temp;
        for(int i= 0; i < arr.length-1; i ++){//有N個元素只需比較N-1次
             for(int  j = arr.length-1; j > i; j --){//比較找到本真趟最小的元素 if(arr[j] < arr[j-1]){                    
                    temp = arr[j]; 
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;
                }                                              
            }
        }            
    }
    public static void main(String[] args) {
        int array[] = {5,8,4,1,2,9};
        System.out.println("排序之前：");
        for(int element : array){
            System.out.print(element + " ");
        }
        
        bubbleSort(array);
        System.out.println("\n排序之后：");
        for(int element : array){
            System.out.print(element + " ");
        }
    }

}

算法改進:在某些情況下，可能在第i趟時元素就已經全部排好序了，此時我們就不必在再進行后面幾趟的比較了。

             如元素：1 2 3 4 9 8 7 6 5    從元素5開始第一趟比較開始，經過4趟的比較后元素由1 2 3 4 9 8 7 6 5  --->   1 2 3 4 5 6 7 8 9  這時由元素4開始進行第5趟比較

             在這趟比較結束后發現並沒有元素進行交換，說明后面的元素已經排好序了，無需再進行比較了。

算法實現：

public class BubbleSort {
//冒泡排序
//核心思想：比較兩個元素，如果前一個比后一個大則進行交換，經過對每個元素的比較，最后最大的元素被放在在最后位置
    public static void bubbleSort(int arr[]){
        int temp;
        for(int i= 0; i < arr.length-1; i ++){//有N個元素只需比較N-1次
            boolean flag = false;             //設置是否有元素交換的標志，false表示沒有，true表示有元素進行交換 for(int  j = arr.length-1; j > i; j --){
                if(arr[j] < arr[j-1]){
                    temp = arr[j]; 
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;  //元素移動了3次
                    flag = true;    //如果交換了則變為true                
                }    
                                          
            }
            if(!flag)//如：5 4 3 2 1 7 8 9
                break; //如果flag為false，則說說明這一趟沒有起先交換 ，已經排序好了，就不用再比較了
        }
    }
    public static void main(String[] args) {
        int array[] = {5,8,4,1,2,9};
        System.out.println("排序之前：");
        for(int element : array){
            System.out.print(element + " ");
        }
        
        bubbleSort(array);
        System.out.println("\n排序之后：");
        for(int element : array){
            System.out.print(element + " ");
        }
    }

}

算法分析：1.若初始數據序列是正序的，則進行一趟的比較后就完成了排序，此時比較的次數和移到次序均達到最小值：C_min = n-1    M_min = 0;

                 時間復雜度為O(n);(n為元素個數)

              2.若元素數據序列是反序，則需要進行n-1趟排序，每趟排序要進行n-i+1次比較(0≤i<n,i為趟數)，且每趟比較都必須移動元素3次來交換元素位置。此時比較的次數和移動次數均達到最大值：C_max = (n-1)+(n-2)+(n-3)+....+1 = n*(n-1)/2 = O(n²)     M_max  = 3*[(n-1)+(n-2)+(n-3)+....+1] = 3*[n*(n-1)/2] = O(n²) ;

                 時間復雜度為O(n²) ;

              3.在冒泡排序中只使用了i,j,temp,flag這4個輔助變量，與問題規模n無關，所以空間復雜度為O(1)。

              4.當i > j且arr[i] = arr[j]時，兩者不進行交換，arr[i]和arr[j]的相對位置保持不變，所以冒泡排序是一種穩定的排序。