冒泡排序算法

一、算法思想

冒泡排序是一种交换排序算法，元素通过两两的比较，交换不满足次序要求的元素，直到整个数组都满足次序要求为止。

比如一个无序的数组中有元素[4,3,8,6,1]，如果按照升序的排序顺序，则采用冒泡排序的过程则是：

第一趟排序：先是4和3比较，4比3大，则交换位置，则顺序是

                      3 4 8 6 1

                      然后4和8比较，8比4大，则不交换顺序，顺序还是

                      3  4 8 6 1

                      然后8和6比较，8比6大，则交换顺序，则顺序是

                      3  4 6  8 1

                      然后 8 和 1 比较 8 比1 大，则交换顺序，则顺序是

                      3  4 6 1 8

                     所以第一趟排序的最终结果是3 4 6 1 8，即最大的元素在最后的位置。

第二趟排序：3 和 4 比较，3 比 4小，不交换顺序，顺序不变

                      4 和 6 比较，4 比6 小，不交换顺序，顺序不变

                      6 和 1 比较，6 比 1 大，交换顺序，则顺序为 3 4 1 6 8，

                      6 和 8 比较，6 比 8 小，不交换顺序，则顺序为3 4 1 6 8

                     所以第二趟的排序结果为3 4 1 6 8，即第二大的元素在倒数第二的位置

  第三趟排序  3 和 4 比较 不交换顺序

                      4 和 1 比较 交换顺序，交换后顺序为3 1 4 6 8

                      .。。。。后面已经为顺序了，交换顺序不变，

                      所以第三趟的排序为3 1 4 6 8，即第三大的顺序在倒数第三的位置

第四趟排序   3 和 1 比较，交换顺序，交换后排序为 1 3 4 6 8，

经过四趟排序，数组为顺序数组。

二、算法分析

        通过上述演示，我们可以发现当长度为N的数组的初始状态是顺序的，则一趟排序即可完成排序。比较次数为N-1和记录移动次数为0，均为最小值。所以，冒泡排序最好时间复杂度为O(N)。
        当数组的初始顺序是倒叙的，则需要进行 N -1 趟排序。每趟排序要进行 N - i 次关键字的比较(1 ≤ i ≤ N - 1)，每次比较都必须移动记录三次来达到交换记录位置。比较和移动次数均达到最大值N^2,所以冒泡排序的最坏时间复杂度为O(N^2)。
         所以，冒泡排序的平均时间复杂度为O(N^2)。

         当两个元素大小相等时，相对位置不会发生改变，所以冒泡排序是稳定的排序算法

三、Java代码

      

public class Main {

    public static void main(String[] args) {
        int[] array = {4,1,3,2};
        System.out.println("排序前=======");
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
        maopaoSort(array);

        System.out.println("排序后=======");
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }

    public static void maopaoSort(int[] array){
        for(int i=0;i<array.length-1;i++){
            for(int j=1;j<=array.length-1;j++){
                if(array[j]<array[j-1]){
                    int temp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = temp;
                }
            }
        }
    }

排序前=======
4 1 3 2 
排序后=======
1 2 3 4