Java实现冒泡排序及优化

一.原理讲解

　　　　冒泡排序即:第一个数与第二个数进行比较,如果满足条件位置不变,再把第二个数与第三个数进行比较.不满足条件则替换位置,再把第二个数与第三个数进行比较,以此类推,执行完为一个趟,趟数等于比较的个数减一.

二、实现思路

       用二重循环实现，外循环变量设为i，内循环变量设为j。假如有n个数需要进行排序，则外循环重复n-1次，内循环依次重复n-1，n-2，...，1次。每次进行比较的两个元素都是与内循环j有关的，它们可以分别用a[j]和a[j+1]标识，i的值依次为1,2,...,n-1，对于每一个i，j的值依次为0,1,2,...n-i 。

设数组长度为N：
1．比较相邻的前后二个数据，如果前面数据大于后面的数据，就将二个数据交换。
2．这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置。
3．N=N-1，如果N不为0就重复前面二步，否则排序完成。

三、代码实现

/**
     * 简单冒泡排序,泡向上走，未优化
     * @param arrays
     * @return
     */
    public static int[] bubblingSort(int[]arrays){
        if (arrays == null || arrays.length <= 0) {
            return null;
        }
        for (int i=0;i<arrays.length-1;i++){
            for(int j=arrays.length-1;j>0;j--){
                if (arrays[j]<arrays[j-1]){
                    int temp = arrays[j];
                    arrays[j] = arrays[j-1];
                    arrays[j-1] = temp;
                }
            }
        }
        return arrays;
    }

    /**
     * 冒泡排序，向下走，未优化
     * @param arrays
     * @return
     */
    public static int [] bubblingSortDown(int[]arrays){
        if (arrays == null || arrays.length <= 0) {
            return null;
        }
        for (int i=0;i<arrays.length-1;i++){
            for (int j=0;j<arrays.length-i-1;j++){
                if (arrays[j]>arrays[j+1]){
                    int temp = arrays[j];
                    arrays[j] = arrays[j+1];
                    arrays[j+1] = temp;
                }
            }
        }
        return arrays;
    }

四.算法优化

1.通过减少无效的循环趟数，因为当排一定趟数后其实数组已经有序了，但是循环扔在继续，所以我们加一个标志位来判断是否数组已经有序。

/**
     * 简单冒泡排序,泡向上走，第一次优化（减少循环比较趟数）
     * @param arrays
     * @return
     */
    public static int[] bubblingSortOptimize(int[]arrays){
        if (arrays == null || arrays.length <= 0) {
            return null;
        }
        for (int i=0;i<arrays.length-1;i++){
            // 优化冒泡排序，增加判断位，有序标记，每一轮的初始是true
            boolean flag = true;
            for(int j=arrays.length-1;j>0;j--){
                if (arrays[j]<arrays[j-1]){
                    int temp = arrays[j];
                    arrays[j] = arrays[j-1];
                    arrays[j-1] = temp;
                    flag = false;
                }
            }
            if (flag){
                break;
            }
        }
        return arrays;
    }

    /**
     * 冒泡排序，向下走，第一次优化（减少循环比较趟数）
     * @param arrays
     * @return
     */
    public static int [] bubblingSortDownOptimize(int[]arrays){
        if (arrays == null || arrays.length <= 0) {
            return null;
        }
        for (int i=0;i<arrays.length-1;i++){
            // 优化冒泡排序，增加判断位，有序标记，每一轮的初始是true
            boolean flag = true;
            for (int j=0;j<arrays.length-i-1;j++){
                if (arrays[j]>arrays[j+1]){
                    int temp = arrays[j];
                    arrays[j] = arrays[j+1];
                    arrays[j+1] = temp;
                    flag = false;
                }
            }
            if (flag){
                break;
            }
        }
        return arrays;
    }

2.优化二，减少内循环中的循环次数，优势后面其实已经有序了，但是每次循环还在比较

/**
     * 冒泡排序，向下走，第二次优化（减少每趟循环次数）
     * @param arrays
     * @return
     */
    public static int [] bubblingSortDownOptimize2(int[]arrays){
        if (arrays == null || arrays.length <= 0) {
            return null;
        }
        // 最后一次交换的下标
        int lastSwapIndex = 0;
        // 无序数组的边界，每次比较比到这里为止
        int arrBoundary = arrays.length - 1;
        for (int i=0;i<arrays.length-1;i++){
            // 优化冒泡排序，增加判断位，有序标记，每一轮的初始是true
            boolean flag = true;
            for (int j=0;j<arrBoundary;j++){
                if (arrays[j]>arrays[j+1]){
                    int temp = arrays[j];
                    arrays[j] = arrays[j+1];
                    arrays[j+1] = temp;
                    flag = false;
                    // 最后一次交换元素的位置
                    lastSwapIndex = j;
                }
            }
            // 把最后一次交换元素的位置赋值给无序数组的边界
            arrBoundary = lastSwapIndex;
            if (flag){
                break;
            }
        }
        return arrays;
    }