面试中常考的排序算法----冒泡排序

冒泡排序

什么是冒泡排序

  冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误
就把他们交换过来。走访元素的工作是重复地进行，直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中
二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

思路分析:

1. 循环轮数(i) = 数组的长度 - 1,假设有10个元素,其实只要比较9轮就可以完成排序,因为每轮都能排 好一个元素,最后一轮只剩最后一个元素,就不需要再比较了。
2. 每一轮比较次数(j) = 数组长度 - 轮的序号,j只能从0开始,因为j控制着数组下标,如果i从1开始,每轮就比较arr.length-i次,如果i从0开始,就需要再减1,比较arr.length-i-1次。
   

代码

public class Bubble {
    public static void main(String[] args) {
        int[] arr = {1,3,2,6,5,9,8,7};
        //打印数组
        System.out.println("排序之前:");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"  ");
        }
        //使用冒泡排序,升序
        //控制轮数
        for (int i = 1; i <arr.length-1  ; i++) {
            //每一轮比较次数
            for (int j = 0; j <arr.length-i; j++) {
                //比较, 如果违反规则,进行交换
                if(arr[j] > arr[j+1]){ //前一个数大于后一个数
                    int temp = arr[j]; //前一个数
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        //打印数组
        System.out.println("\n排序之后:");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"  ");
        }
    }
}

运行结果

拓展

 ***1. 交换元素值***
方式一：定义一个临时变量（temp）
                    int temp = arr[j]; //前一个数
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
方式二：异或 （其实现主要是基于异或运算的如下性质：）
    1.任意一个变量X与其自身进行异或运算，结果为0，即X^X=0
    2.任意一个变量X与0进行异或运算，结果不变，即X^0=X
    3.异或运算具有可结合性，即a^b^c=（a^b）^c=a^（b^c）
    4.异或运算具有可交换性，即a^b=b^a
   				 arr[j] = arr[j] ^ arr[j+1];
                 arr[j+1] = arr[j] ^ arr[j+1];
                 arr[j] = arr[j] ^ arr[j+1];
方式三：加减
				 arr[j] = arr[j] + arr[j+1];
				 arr[j+1] = arr[j] - arr[j+1];
				 arr[j] = arr[j] - arr[j+1];
方式四：乘除
			    arr[j] = arr[j] * arr[j+1];
                arr[j+1] = arr[j] / arr[j+1];
                arr[j] = arr[j] / arr[j+1];			
 **2. 打印数组**
方式一：遍历数组
		for (int i = 0; i < arr.length; i++) {
          	  System.out.print(arr[i]+"  ");
        }

方式二：利用Arrays（一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。）
		System.out.println(Arrays.toString(arr));

                     
          

代码再优化

分析：按上述代码排序，有可能在第3轮或者其他轮就已经排序完成，但是代码并不知道排序完成，还是会继续执行，此时，我们可以设置一个标志位flag = true；（表示代码已完成排序）如果执行交换代码，也就是还没排好，就把flag = flase；如果没有交换代码，就证明排序已经完成，也就是flag = true;成立，退出循环。 代码优化如下：

public class Bubble {
    public static void main(String[] args) {
        int[] arr = {1,3,2,6,5,9,8,7};
        //打印数组
        System.out.println("排序之前:");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        //使用冒泡排序,升序
        //控制轮数
        boolean flag = true; //排好,为了优化
        for (int i = 1; i <arr.length-1  ; i++) {
            //每一轮比较次数
            for (int j = 0; j <arr.length-i; j++) {
                //比较, 如果违反规则,进行交换
                if(arr[j] > arr[j+1]){ //前一个数大于后一个数
                    //进来, 表示肯定没有排好
                    flag = false;//没有排好
                    int temp = arr[j]; //前一个数
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            //如果排好,退出循环
            if(flag){
                break; //退出外层循环
            }
        }
        //打印数组
        System.out.println("\n排序之后:");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

时间复杂度

计算时间复杂度无非就是计算循环次数：
假设有n个元素，第1轮，比较n-1次，第2轮，比较n-2次，第3轮，比较n-3次，第n-1轮，比较1次，
这是一个等差数列（求和公式：(首项+末项)×项数÷2）),所以n-1+n-2+n-3+…+1求和结果为n*(n-1)/2,当n足够大的时候,n-1=n,除以2也无影响,结果为n^2,所以最差的情况时间复杂度为:O( n^2 ) ,最优的情况也就是开始就已经排序好序了，最优的时间复杂度为：O(n)