数据结构之冒泡排序

排序思路：整个算法从最下面的元素开始，对相邻的元素进行比较，经过交换使得较小的元素在较大的元素之上，经过对每个元素的两两比较，最后最小的元素被移到前面的位置。

算法实现：

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("
排序之后：");
        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 == false)//如：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("
排序之后：");
        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]的相对位置保持不变，所以冒泡排序是一种稳定的排序。

原本转自：http://www.cnblogs.com/MOBIN/p/4677228.html