java实现冒泡排序

基础冒泡排序

/**
     * 基础冒泡排序
     * @param arrays 数组
     * @return 返回排序后数组
     */
    public static int[] bubbleSort1(int[] arrays){
        if (arrays == null){
            return null;
        }
        //第一个循环代表遍历轮次，第二个遍历用来遍历交换数据
        for (int i=0;i<arrays.length-1;i++){
            //标记某一轮遍历中是否发生交换，false为否，true为是
            boolean exchanged = false;
            int n = 0;
            for (int j=1;j<arrays.length-i;j++){
                //前一个元素值大于后一个元素值时交换，即升序
                if (arrays[j-1] > arrays[j]){
                    System.out.println("第"+ (i+1) +"次遍历，第"+ ++n +"次交换");
                    //交换
                    swap(arrays,j);
                    //标记发生交换
                    exchanged = true;
                    System.out.println(Arrays.toString(arrays)+"----"+j);
                }
                System.out.println("第"+ (i+1) +"次遍历，第"+ j +"次比较");
            }
            //上一轮没有发生交换，即已排好序，退出循环
            if (!exchanged){
                break;
            }
        }
        return arrays;
    }

加入边界有序边界冒泡排序

/**
     * 加入有序边界冒泡排序
     * @param arrays 待排序数组
     * @return 返回已排序数组
     */
    public static int[] bubbleSort2(int[] arrays){
        if (arrays == null){
            return null;
        }
        //遍历边界，边界之后为已排好序的数据，不再遍历边界之后的数据
        int sortBorder = arrays.length;
        //标记在某一次遍历中最后一个次交换的下标，并将此值赋值给sortBorder
        int lastExchangeIndex = 0;
        for (int i=0;i<arrays.length-1;i++){
            //标记某一轮遍历中是否发生交换，false为否，true为是
            boolean exchanged = false;
            int n = 0;
            for (int j=1;j<sortBorder;j++){
                //前一个元素值大于后一个元素值时交换，即升序
                if (arrays[j-1] > arrays[j]){
                    System.out.println("第"+ (i+1) +"次遍历，第"+ ++n +"次交换");
                    //交换数据
                    swap(arrays,j);
                    //标记发生交换
                    exchanged = true;
                    //标记交换的下标
                    lastExchangeIndex = j;
                    System.out.println(Arrays.toString(arrays)+"----"+j);
                }
                System.out.println("第"+ (i+1) +"次遍历，第"+ j +"次比较");
            }
            //赋值边界
            sortBorder = lastExchangeIndex;
            //上一轮没有发生交换，即已排好序，退出循环
            if (!exchanged){
                break;
            }
        }
        return arrays;
    }

/**
     * 交换数据
     * @param arrays 待排序数组
     * @param j 需要交换的下标
     */
    private static void swap(int[] arrays,int j){
        int temp = arrays[j];
        arrays[j] = arrays[j-1];
        arrays[j-1] = temp;
    }

public static void main(String[] args) {
        int[] s1 = new int[]{3,4,2,1,5,6,7,8};
        int[] s2 = new int[]{3,4,2,1,5,6,7,8};
        System.out.println("-------------------------------基础冒泡排序---------------------------------------");
        System.out.println(Arrays.toString(bubbleSort1(s1)));
        System.out.println("-------------------------------优化有序边界冒泡排序-------------------------------");
        System.out.println(Arrays.toString(bubbleSort2(s2)));
       
    }

测试结果

-------------------------------基础冒泡排序---------------------------------------
第1次遍历，第1次比较
第1次遍历，第1次交换
[3, 2, 4, 1, 5, 6, 7, 8]----2
第1次遍历，第2次比较
第1次遍历，第2次交换
[3, 2, 1, 4, 5, 6, 7, 8]----3
第1次遍历，第3次比较
第1次遍历，第4次比较
第1次遍历，第5次比较
第1次遍历，第6次比较
第1次遍历，第7次比较
第2次遍历，第1次交换
[2, 3, 1, 4, 5, 6, 7, 8]----1
第2次遍历，第1次比较
第2次遍历，第2次交换
[2, 1, 3, 4, 5, 6, 7, 8]----2
第2次遍历，第2次比较
第2次遍历，第3次比较
第2次遍历，第4次比较
第2次遍历，第5次比较
第2次遍历，第6次比较
第3次遍历，第1次交换
[1, 2, 3, 4, 5, 6, 7, 8]----1
第3次遍历，第1次比较
第3次遍历，第2次比较
第3次遍历，第3次比较
第3次遍历，第4次比较
第3次遍历，第5次比较
第4次遍历，第1次比较
第4次遍历，第2次比较
第4次遍历，第3次比较
第4次遍历，第4次比较
[1, 2, 3, 4, 5, 6, 7, 8]

-------------------------------优化有序边界冒泡排序---------------------------------------
第1次遍历，第1次比较
第1次遍历，第1次交换
[3, 2, 4, 1, 5, 6, 7, 8]----2
第1次遍历，第2次比较
第1次遍历，第2次交换
[3, 2, 1, 4, 5, 6, 7, 8]----3
第1次遍历，第3次比较
第1次遍历，第4次比较
第1次遍历，第5次比较
第1次遍历，第6次比较
第1次遍历，第7次比较
第2次遍历，第1次交换
[2, 3, 1, 4, 5, 6, 7, 8]----1
第2次遍历，第1次比较
第2次遍历，第2次交换
[2, 1, 3, 4, 5, 6, 7, 8]----2
第2次遍历，第2次比较
第3次遍历，第1次交换
[1, 2, 3, 4, 5, 6, 7, 8]----1
第3次遍历，第1次比较
[1, 2, 3, 4, 5, 6, 7, 8]