JAVA--冒泡排序

冒泡排序原理：

一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所 有的数据进行操作，直至所有数据按要求完成排序 。

• 如果有n个数据进行排序，总共需要比较n-1次
• 每一次比较完毕，下一次的比较就会少一个数据参与  

假如有如下身高的小人：

相邻的两个两两相比较，前者大于后者，则交换位置，一直比较下去。

所以，第一轮下来是：

第二轮：

第三轮：

第四轮（即N-1轮，N=5个数）：

这样就排序完了。 

冒泡排序算法分析

时间复杂度

若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数

和记录移动次数

均达到最小值：

，

。

所以，冒泡排序最好的时间复杂度为

。
　　若初始文件是反序的，需要进行

趟排序。每趟排序要进行

次关键字的比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：

冒泡排序的最坏时间复杂度为

。 [1] 

综上，因此冒泡排序总的平均时间复杂度为

。

引用百度百科。

冒泡排序优点： 

        每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值，一定程度上减少了算法的量。

代码实现：

1、分析每次排序后的情况

public class ArraySort {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {195, 180, 190, 206, 160};
        System.out.println("排序前：" + arrayToString(arr));


        //第一次比较
        for(int i=0; i<arr.length-1-0; i++) {
            //ArrayIndexOutOfBoundsException
            if(arr[i] > arr[i+1]) {
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第一次比较后：" + arrayToString(arr));

        //第二次比较
        for(int i=0; i<arr.length-1-1; i++) {
            //ArrayIndexOutOfBoundsException
            if(arr[i] > arr[i+1]) {
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第二次比较后：" + arrayToString(arr));

        //第三次比较
        for(int i=0; i<arr.length-1-2; i++) {
            //ArrayIndexOutOfBoundsException
            if(arr[i] > arr[i+1]) {
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第三次比较后：" + arrayToString(arr));

        //第四次比较
        for(int i=0; i<arr.length-1-3; i++) {
            //ArrayIndexOutOfBoundsException
            if(arr[i] > arr[i+1]) {
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第四次比较后：" + arrayToString(arr));
        
    }

    //把数组中的元素按照指定的规则组成一个字符串
    public static String arrayToString(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(", ");
            }
        }
        sb.append("]");
        String s = sb.toString();
        return s;
    }
}

2、直接看排序后的情况：

public class ArraySort {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {195, 180, 190, 206, 160};
        System.out.println("排序前：" + arrayToString(arr));
        


        for(int x=0; x<arr.length-1; x++) {
            for(int i=0; i<arr.length-1-x; i++) {
                if(arr[i] > arr[i+1]) {
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }
        System.out.println("排序后：" + arrayToString(arr));
    }
    //把数组中的元素按照指定的规则组成一个字符串
    public static String arrayToString(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(", ");
            }
        }
        sb.append("]");
        String s = sb.toString();
        return s;
    }
}