001-排序算法-冒泡排序

0、前提备注概述

　　对于基础的说明可以参看

　　001-数据结构与算法基本概念

　　002-数据结构之算法的时间复杂度和空间复杂度

一、概述

　　冒泡排序(Bubble Sort)，又被称为气泡排序或泡沫排序。它是一种较简单的排序算法。

　　规则：每次比较两个相邻的元素，将较大的元素交换至右端。

排序方法	时间复杂度（平均）	时间复杂度 （最坏）	时间复杂度（最好）	空间复杂度	稳定性
冒泡排序	O(n^2)	O(n^2)	O(n)	O(1)	稳定

1.1、冒泡排序时间复杂度

冒泡排序的时间复杂度是O(N²)。
假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N)，需要遍历多少次呢？N-1次！因此，冒泡排序的时间复杂度是O(N²)。

1.2、冒泡排序稳定性

冒泡排序是稳定的算法，它满足稳定算法的定义。
算法稳定性 -- 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的！

1.3、算法说明

　　

3和44比较，3<44位置不变；44和38比较，44>38交换,

1.4、代码

    /*
     * 冒泡排序 下沉排序
     */
    public static void bubbleSort1(int[] a) {
        int i,j,n=a.length;
        if (n <= 1) return;       //如果只有一个元素就不用排序了

        //倒着来，主要是大数下沉
        //循环数组长度次
        for (i=n-1; i>0; i--) {
            // 将a[0...i]中最大的数据放在末尾
            // j<i 含义是，每一次比较后，都会有一个相对大数排在最后
            for (j=0; j<i; j++) {
                if (a[j] > a[j+1]) {//相邻的两个数比较，前面的大于后面的交换即可
                    // 交换a[j]和a[j+1]
                    int tmp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = tmp;
                }
            }
        }
    }

优化方案

增加一个标志位，有序就退出好了

    /*
     * 冒泡排序(改进版) 下沉排序
     */
    public static void bubbleSort2(int[] a) {
        int i,j,n=a.length;
        if (n <= 1) return;       //如果只有一个元素就不用排序了

        for (i=n-1; i>0; i--) {

            boolean flag = false; // 提前退出冒泡循环的标志位,即一次比较中没有交换任何元素，这个数组就已经是有序的了
            // 将a[0...i]中最大的数据放在末尾
            for (j=0; j<i; j++) {
                if (a[j] > a[j+1]) {
                    // 交换a[j]和a[j+1]
                    int tmp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = tmp;

                    flag = true;    // 若发生交换，则设标记为1
                }
            }

            if (!flag)
                break;            // 若没发生交换，则说明数列已有序。
        }
    }

代码地址：地址 中的rithm-001-sort中 BubbleSort