排序算法:冒泡排序

Sorting Algorithms:Bubble Sort

前言

该博客用于本弱鸡复习巩固，打牢基础，还望各大佬不吝赐教。

基本思路

该算法对一个数组中的相邻的每一对数字都进行比较，
假如令大的在前，小的在后，该数组有n个元素,
第一次对该数组的所有相邻元素比较，
比较完后则会排列出整个数组最小元素放在最后，
接着第二次只需对剩下的 n-1 个相邻的元素进行比较，
排序出第二小的元素，
以此类推进行第 3，4，5，6，7…到 n-1 次,
因为第 n-1 次排出第二大的元素，自然剩下那个就是最大的元素。

“这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。”
每次排序‘浮’出的都是最小的。

动图示例

算法复杂度分析

p.s. 最好情况：即已经数组按顺序排好的情况，加了flag判定后，内循环执行一次即可不再执行

代码实现

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Random;

/**
 * Bubble Sort :
 * 该算法对一个数组中的相邻的每一对数字都进行比较，
 * 假如令大的在前，小的在后，该数组有n个元素
 * 第一次对该数组的所有相邻元素比较，
 * 比较完后则会排列出整个数组最小元素放在最后，
 * 接着第二次只需对剩下的 n-1 个相邻的元素进行比较，
 * 排序出第二小的元素，
 * 以此类推进行第 3，4，5，6，7...到 n-1 次
 * 因为第 n-1 次排出第二大的元素，自然剩下那个就是最大的元素
 *
 * “这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。”
 * 每次排序‘浮’出的都是最小的
 *
 * 算法复杂度分析
 * 时间复杂度（平均）   O(n^2) 外循环n次，内循环m次 m*n
 * 时间复杂度（最坏）   O(n^2) 外循环n次，内循环m次 m*n
 * 时间复杂度（最好）   O(n) (即已经数组按需排好的情况，加了flag判定后，内循环执行一次即可不再执行)
 * 空间复杂度           O(1)
 * 稳定性             稳定
 *
 * @author Wayne Zhang
 * @date 2018/07/14
 */

public class BubbleSort {

    public static void main(String[] args) {

        int[] a = new int[10];
        boolean flag = true;
        //random array
        for (int i = 0; i < a.length; i++) {
            Random rd = new Random();
            a[i] = rd.nextInt(10);
        }

        System.out.println("Random Array :");
        System.out.println(Arrays.toString(a));
        System.out.println();
        System.out.println("Bubble Sort :");

        //冒泡排序开始
        //外循环规定了排序次数，从第1次到第 n-1 次
        for (int i = 0; i < a.length - 1 && flag; i++) {
            flag = false;
            //内循环规定了剩余未排序元素,j是从后往前循环
            for (int j = a.length - 2; j >= i; j--) {
                //前一个大于后一个，则交换
                if (a[j] > a[j + 1]) {
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                    flag = true;
                }
            }
        }
        // 另一种形式
        // This might be easy for you to understand.
        /*for(int i = 0; i < a.length - 1 && flag; i++){
            flag = false;
            for(int j =0 ;j<a.length-i-1;j++){
                if(a[j]>a[j+1]){
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                    flag = true;
                }
            }
        }*/

        System.out.println(Arrays.toString(a));

    }
}

相关概念

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。

不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。

参考

GeekforGeeks-Bubble Sort： https://www.geeksforgeeks.org/bubble-sort/

十大经典排序算法：https://www.cnblogs.com/onepixel/articles/7674659.html