java面试题：冒泡排序

冒泡排序：

依次比较数组a中相邻两个元素的大小，如果a[i]>a[i+1]，则两个元素交换位置，两两都比较一遍后称为一次冒泡，让最大的元素排至最后。然后继续重复以上步骤，直至数组有序。

代码表示：

第一次排序：

public class maopaopaixu {
    public static void main(String[] args) {
        int[] a= {1,4,7,3,9,6,5};
        qqq(a);
    }

    private static void qqq(int[] a) {

        //第一次排序
        for (int i = 0; i < a.length-1; i++) {
            if (a[i]>a[i+1]){
                swap(a,i,i+1);
            }
        }
        System.out.println(Arrays.toString(a));
    }

    private static void swap(int[]a ,int i,int j) {
        //交换顺序
        int t= a[i];
        a[i]= a[j];
        a[j]=t;
    }


}

运行结果：

我们可以看到第一次排序结束后，最大的数9已经换到了最后，要完整的完成冒泡排序，我们只需要在嵌套一次循环即可。

 private static void qqq(int[] a) {
        for (int j = 0; j < a.length - 1; j++) {
            //第一次排序
            for (int i = 0; i < a.length-1; i++) {
                System.out.println("排序次数："+i);
                if (a[i]>a[i+1]){
                    swap(a,i,i+1);
                }
            }
            System.out.println("第"+ j+"轮冒泡"+Arrays.toString(a));

        }

再次运行代码，最终结果如下图所示：

冒泡排序优化：

排序次数优化：

我们通过观察控制台每轮打印的排序次数可以知道，每次排序都要进行6次，这是因为第一次排序之后最后一个数和倒数第二个数已经比较完成，但是在第二轮排序的时候后依然会将他们进行比较，但实际他们是不用比较的，以此类推，其实每一轮的排序次数应该是越来越少所以我们要将代码进行优化：

private static void qqq(int[] a) {
        for (int j = 0; j < a.length - 1; j++) {
            //第一次排序
            for (int i = 0; i < a.length-1-j; i++) {
                System.out.println("排序次数："+i);
                if (a[i]>a[i+1]){
                    swap(a,i,i+1);
                }
            }
            System.out.println("第"+ j+"轮冒泡"+Arrays.toString(a));

        }
    }

优化后打印结果依然不变，只是每轮排序次数会逐渐减少：

冒泡轮数优化：

从上图可以看出，我们在第二轮冒泡已经完成了排序，但是后面的还是会继续执行，为了减少不必要的冒泡次数，我们对代码进行如下修改：

    private static void qqq(int[] a) {
        for (int j = 0; j < a.length - 1; j++) {
            boolean wap = false;//是否发生了交换
            //第一次排序
            for (int i = 0; i < a.length-1-j; i++) {
                System.out.println("排序次数："+i);
                if (a[i]>a[i+1]){
                    swap(a,i,i+1);
                    wap=true;

                }
            }
            if (!wap){
                break;
            }
            System.out.println("第"+ j+"轮冒泡"+Arrays.toString(a));
        }
    }

上述代码运行结果为;

可以看出在第二轮冒泡对数组排序完成后，便不再执行。

最终优化：

举一组例子，{3，5，7，4，8，9},在上述优化中经过第一轮优化后数组会变成{3，5，4，7,8,9}

其中7,8,9其实已经不用在进行冒泡排序了，而在上述第一次优化中，8，9不用在进行排序，而7,8仍然要进行排序，但实际上是不用进行排序的，所以我们进一步优化：

 private static void qqq(int[] a) {
        int n = a.length-1;
        while (true){
            int last = 0;
            for (int i = 0; i < n; i++) {
                System.out.println("比较次数:"+i);
                if(a[i]>a[i+1]){
                    swap(a,i,i+1);
                    last=i;
                }
            }
            n=last;
            if (n==0){
                break;
            }
            System.out.println("第"+"轮冒泡"+Arrays.toString(a));
        }
    }

面试时，最少要将前两种优化写出来。