基础排序算法（一）——用Java实现的冒泡排序算法以及优化思路

 

​​​​​​前言

冒泡排序是最基础的排序算法之一，下面总结冒泡排序的三种实现方式，并总结下优化思路。

正文

思路：每一趟遍历将最大元素冒泡到数组最后的位置；

public class BubbleSort {

    
    // 方式1
    public static void sort(int[] arr) {
        int n = arr.length;

        if (n <= 1) {
            return;
        }

        boolean swapped = false;

        do {
            swapped = false;
            for (int i = 1; i < n; i++) {
                if (arr[i - 1] > arr[i]) {
                    swap(arr, i - 1, i);
                    swapped = true;
                }
            }
        } while(swapped);
    }

    // 方式2
    public static void sort2(int[] arr) {
        int n = arr.length;

        if (n <= 1) {
            return;
        }

        // 使用newn来进行优化
        int newn;

        do {
            newn = 0;
            for (int i = 1; i < n; i++) {
                if (arr[i - 1] > arr[i]) {
                    swap(arr, i - 1, i);
                    // 记录当前排序最后一次交换的位置，在此之后的元素在下一轮扫描中均不考虑
                    newn = i;
                }
            }
            n = newn;
        } while (newn > 0);

    }

    // 方式3
    public static void sort3(int[] arr) {
        int n = arr.length;
        if (n <= 1) {
            return;
        }

        for (int i = 0; i < n; i++) {
            boolean flag = false;

            // n - i - 1 表示每轮排序都会有一个最大元素冒泡到最大位置，因而每轮排序都会少一个遍历的元素
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] < arr[j + 1]) {
                    swap(arr, j, j + 1);
                    flag = true;
                }
            }
            // 此轮排序没有数据交换，则退出排序
            if (!flag) {
                break;
            }
        }
    }


    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

总结

方式1是最简单的排序方法，就是简单的两层循环遍历；

方式2和3都是在方式1的基础上进行了优化，由于每轮排序都会将最大的元素放在最后一位，所以在下一次排序就不需要考虑前一次的最大元素了。

本人将自己学习的算法和数据结构都记录在github中，感兴趣的小伙伴star支持下，地址列在下面：

https://github.com/coderbruis/AlgorithmsInJava