Java—冒泡排序

冒泡排序是一种简单的排序算法。它重复地遍历要排序的数组，比较相邻两个元素，如果他们的顺序错误就交换他们的位置，直到遍历完整个数组。

实现步骤

以下是冒泡排序的实现过程：

1. 从数组的第一个元素开始，对相邻的两个元素进行比较，如果第一个元素比第二个元素大，则交换它们的位置。
2. 继续进行比较，直到把最大的元素放到了最后一个位置。
3. 重复以上步骤，但是不包括已经排序好的最后一个元素（因为它已经排好序了），直到整个数组都被排序好。

实现代码

import java.util.Arrays;

public class BubbleSort {


    public static void main(String[] args){
        int[] arr = { 4,7,2,8,3,5,0,10};

        // 排序
        bubbleSort(arr);

        // 输出结果
        System.out.println(Arrays.toString(arr));
    }

    // 普通实现
    public static void bubbleSort(int[] arr){
        // i : 表示已经排好序的个数
        // arr.length -1 : 表示数组最后一个元素就不用排序了。
        for(int i = 0; i < arr.length - 1 ; i++){
            // j ：当前比较的位置。
            // arr.length-i-1 : 表示后面的已经排好序的不用在参与排序。
            for(int j = 0;j < arr.length - 1 - i; j++){
                // 当前元素和后一个元素比较，如果当前元素比后一个元素大，就交换。
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

测试结果

产生问题

对于已经排好序的数组，冒泡排序算法的缺点是它仍然会执行完所有的比较和交换操作，即使在每一轮中没有发生任何交换。

为了改进冒泡排序算法在已经排好序的情况下的效率，可以引入一个标志变量来判断是否发生了交换。如果在一轮中没有发生任何交换，说明数组已经是有序的，可以提前结束排序过程。

改进代码

以下是改进后的代码：

    // 改进实现
    public static void bubbleSort2(int[] arr){

        // 定义一个变量，用于记录是否发生过交换。
        boolean flag = true;

        // i : 表示已经排好序的个数
        // arr.length -1 : 表示数组最后一个元素就不用排序了。
        for(int i = 0; i < arr.length - 1 ; i++){
            // j ：当前比较的位置。
            // arr.length-i-1 : 表示后面的已经排好序的不用在参与排序。
            for(int j = 0;j < arr.length - 1 - i; j++){
                // 当前元素和后一个元素比较，如果当前元素比后一个元素大，就交换。
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    // 如果发生过交换就设置标志为false
                    flag = false;
                }
            }

            // 如果到这里flag任然为true；说明一次都没有交换过，数组就已经是排好序的了。
            if(flag){
                break;
            }
        }
    }

前后对比

import java.util.Arrays;

public class BubbleSort {


    public static void main(String[] args){
        int[] arr = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
        int[] arr2 = Arrays.copyOf(arr, arr.length);
        
        // 改进前的
        bubbleSort(arr);
        
        // 改进后的
        bubbleSort2(arr2);

        // 输出结果
        System.out.println(Arrays.toString(arr));
    }

    // 普通实现
    public static void bubbleSort(int[] arr){
        // 统计循环次数
        int count = 0;

        // i : 表示已经排好序的个数
        // arr.length -1 : 表示数组最后一个元素就不用排序了。
        for(int i = 0; i < arr.length - 1 ; i++){
            // j ：当前比较的位置。
            // arr.length-i-1 : 表示后面的已经排好序的不用在参与排序。
            for(int j = 0;j < arr.length - 1 - i; j++){
                // 当前元素和后一个元素比较，如果当前元素比后一个元素大，就交换。
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
                count++;
            }
        }

        System.out.println("普通实现冒泡排序的循环次数：" + count);
    }

    // 改进实现
    public static void bubbleSort2(int[] arr){
        // 统计循环次数
        int count = 0;

        // 定义一个变量，用于记录是否发生过交换。
        boolean flag = true;

        // i : 表示已经排好序的个数
        // arr.length -1 : 表示数组最后一个元素就不用排序了。
        for(int i = 0; i < arr.length - 1 ; i++){
            // j ：当前比较的位置。
            // arr.length-i-1 : 表示后面的已经排好序的不用在参与排序。
            for(int j = 0;j < arr.length - 1 - i; j++){
                // 当前元素和后一个元素比较，如果当前元素比后一个元素大，就交换。
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    // 如果发生过交换就设置标志为false
                    flag = false;
                }
                count++;
            }

            // 如果到这里flag任然为true；说明一次都没有交换过，数组就已经是排好序的了。
            if(flag){
                break;
            }
        }

        System.out.println("改进后实现冒泡排序的循环次数：" + count);
    }

}