MyFirst_CSDN_改进冒泡排序算法及探讨其时间、空间复杂度

改进冒泡排序

package sort;

public class 冒泡排序 {
    public static void main(String[] args) {
        int[] ints = new int[]{8,3,5,1,9,4,7,2,6,0};
        for (int i:ints)System.out.print(i+"  ");
        System.out.println();
        BetterMaoPao(ints);
        for (int i:ints)System.out.print(i+" ");

    }

    /**
     * 时间复杂度:O(n²)
     * 最好情况:
     *      1、改进后：O(n)  //对于一个有序的数组，实际上只执行了n-1次比较
     *      2、未改进：O(n²)
     * 最坏情况:O(n²)
     * 空间复杂度:O(1)
     * 排序方式:In-place
     * 稳定性:稳定
     * @param array
     */
    public static void BetterMaoPao(int[] array){	 //时间复杂度分析
        int length=array.length;                     //1
        for (int i=0;i<length-1;i++){                //n-1+1=n
            boolean flag=false;                      //1
            for (int j=0;j<(length-i-1);j++){        //max=n-1+1=n  min=1+1  average=(max+min)/2=(n-1)/2    reality=n*(n-1)/2
                if (array[j]>array[j+1]){            //max=n-1 min=1 average=n/2  reality=n*n/2
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                    flag=true;
                }
            }
            if (!flag)break;//对于有序的数组，一次循环后将不发生交换，此时直接跳出循环
        }
    }
}

术语解释：

• 稳定性

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

• 排序方式

In-place: 占用常数内存，不占用额外内存
Out-place: 占用额外内存

• 时间复杂度：一个算法执行所耗费的时间
  计算方式在代码中已有书写

• 空间复杂度：运行完一个程序所需内存的大小

空间复杂度的计算

• O（1）:就看所占用储存空间是否会随着迭代次数n的增加而增加。

例如这个冒泡排序，常见的两层循环。
计算方式： 第一次循环： 1、int local 2、int index
两个声明，开辟两个int长度的储存空间。
以下是：
错误理解：一次循环开辟1个int，则n层循环：n * int
正确理解：每次循环完毕int在本次for循环中的寿命结束，被释放空间，下次循环时总量为1*int,因此最终循环下来内存占用最大时也不过是
length(int *1) + flag(boolean *1) + i(int *1) + j(int *1) + temp(int *1)
因此空间复杂度为O（1）

• O（n）
  首先看代码
  
  这里引用一个博主的回复，觉得比较容易理解