冒泡排序

1.初步实现

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] a = {5,8,56,14,26,34,86,47};
        bubble(a);
        System.out.println(Arrays.toString(a));
    }
    // 冒泡排序
    public static void bubble(int[] a) {
        // 由于每轮冒泡都会确定最后一位的数据，所以只需要经过 数组长度 - 1 的冒泡轮数就可以排序完
        for (int j = 0; j < a.length - 1; j++) {
            // 一轮冒泡
            for (int i = 0; i < a.length - 1; i++) {
                // 大的排在后
                if(a[i] > a[i+1]) {
                    swap(a,i,i+1);
                }
            }
        }
    }
    // 交换元素
    public static void swap (int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

2.优化—-减少内层循环比较次数

在每一轮冒泡的时候，都会比较一定的次数，但是在经过第一轮冒泡的时候，最后一位已经是最大的，无需和其比较，所以可以让比较次数减少

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] a = {5,8,56,14,26,34,86,47};
        bubble(a);
        System.out.println(Arrays.toString(a));
    }
    // 冒泡排序
    public static void bubble(int[] a) {
        // 由于每轮冒泡都会确定最后一位的数据，所以只需要经过 数组长度 - 1 的冒泡轮数就可以排序完
        for (int j = 0; j < a.length - 1; j++) {
            // 一轮冒泡  
            //优化： 每一轮冒泡过后，所需要冒泡比较的次数减一，也就是不和已经排好的数进行比较
            for (int i = 0; i < a.length - 1 - j; i++) {
                // 大的排在后
                if(a[i] > a[i+1]) {
                    swap(a,i,i+1);
                }
            }
        }
    }
    // 交换元素
    public static void swap (int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

3.优化—-减少冒泡轮数

当某一轮冒泡中，发现没有任何元素进行交换，说明此时数组已经排序完成，则可以不用进行接下来无用的冒泡

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] a = {5,8,56,14,26,34,86,47};
        bubble(a);
        System.out.println(Arrays.toString(a));
    }
    // 冒泡排序
    public static void bubble(int[] a) {
        // 定义 flag来标记当前数组是否已经排序完成
        boolean flag = true;
        // 由于每轮冒泡都会确定最后一位的数据，所以只需要经过 数组长度 - 1 的冒泡轮数就可以排序完
        for (int j = 0; j < a.length - 1; j++) {
            // 一轮冒泡
            //优化： 每一轮冒泡过后，所需要冒泡比较的次数减一，也就是不和已经排好的数进行比较
            for (int i = 0; i < a.length - 1 - j; i++) {
                // 大的排在后
                if(a[i] > a[i+1]) {
                    swap(a,i,i+1);
                    // 如有交换 则 表示数组还没有 排好序
                    flag = false;
                }
            }
            // 如果已经排好序，就不用再进行接下来的 冒泡，直接退出循环
            if(flag) {
               break;
            }
        }
    }
    // 交换元素
    public static void swap (int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

4.最终优化

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] a = {5,8,56,14,26,34,86,47};
        bubble_v2(a);
        System.out.println(Arrays.toString(a));
    }
    public static void bubble_v2(int[] a) {
        // 定义 交换次数，初始化为 a.length - 1
        int n = a.length - 1;
        while (true){
            // 定义最后一次交换时的索引位置
            int lastIndex = 0;
            // 每一轮冒泡
            for (int i = 0; i < n; i++) {
                if(a[i] > a[i+1]) {
                    swap(a,i,i+1);
                    //每一轮冒泡，最后一次进行交换时的i的索引值
                    lastIndex = i;
                }
            }
            // 最后一次索引的值作为下一次交换的次数
            n = lastIndex;

            // 当 n的次数为0的时候 就退出循环
            if(n == 0){
                break;
            }
        }
    }
    public static void swap (int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}