冒泡排序的优化

今天在 “Java架构师之路”公众号中学习了 冒泡排序的优化。作者原文写的很清晰，我自己写了一下代码，再次记录下来：

原文链接：点击这里

package io.starter.service;


import java.util.Arrays;


public class BubbleSortTest {
    public static void main(String[] args) {
        int[] array=new int []{5,8,6,3,9,2,1,7};
        sort(array);
        System.out.println(Arrays.toString(array));

        int[] arrayTwo=new int []{3,4,2,1,5,6,7,8};
        sortThree(arrayTwo);
        System.out.println(Arrays.toString(arrayTwo));
    }

    /**
     * 冒泡排序第一版
     * 代码非常简单，使用双循环来进行排序。外部循环控制所有的回合，内部循环代表每一轮的冒泡处理，先进行元素比较，再进行元素交换。
     */
    private static void sort(int[] array){
        int temp=0;
        for (int i=0;i< array.length;i++){
            for (int j=0;j<array.length-i-1;j++){
                    if (array[j]>array[j+1]){
                        temp=array[j];
                        array[j]=array[j+1];
                        array[j+1]=temp;
                    }
            }
        }
    }

    /**
     * 冒泡排序第二版
     * 自从经过第六轮排序，整个数列已然是有序的了。可是我们的排序算法仍然“兢兢业业”地继续执行第七轮、第八轮。
     * 这种情况下，如果我们能判断出数列已经有序，并且做出标记，剩下的几轮排序就可以不必执行，提早结束工作
     */
    private static void sortTwo(int[] array){
        int temp=0;
        for (int i=0;i< array.length;i++){
            //有序标记，每一轮的初始是true
            boolean isSorted=true;
            for (int j=0;j<array.length-i-1;j++){
                if (array[j]>array[j+1]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                    //有元素交换，所以不是有序，标记变为false
                    isSorted=false;
                }
            }
            // 如果在本轮排序中，元素有交换，则说明数列无序；如果没有元素交换，说明数列已然有序，直接跳出大循环。
            if (isSorted){
               break;
            }
        }
    }

    /**
     * 冒泡排序第三版
     * 一：有序区的长度和排序的轮数是相等的。比如第一轮排序过后的有序区长度是1，第二轮排序过后的有序区长度是2、、、
     * 二：实际上，数列真正的有序区可能会大于这个长度，比如例子中仅仅第二轮，后面5个元素实际都已经属于有序区。因此后面的许多次元素比较是没有意义的。
     * 三：如何避免这种情况呢？我们可以在每一轮排序的最后，记录下最后一次元素交换的位置，那个位置也就是无序数列的边界，再往后就是有序区了。
     */
    private static void sortThree(int[] array){
        int temp=0;

        //记录最后一次交换的位置
        int lastExchangeIndex=0;
        //无序数列的边界，每次比较只需要比到这里为止
        int sortBorder=array.length-1;
        for (int i=0;i< array.length;i++){
            //有序标记，每一轮的初始是true
            boolean  isSorted=true;
            for (int j=0;j<sortBorder;j++){
                if (array[j]>array[j+1]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                    //有元素交换，所以不是有序，标记变为false
                    isSorted=false;
                    //把无序数列的边界更新为最后一次交换元素的位置
                    lastExchangeIndex=j;
                }
            }
            sortBorder=lastExchangeIndex;
            if (isSorted){
                break;
            }
        }
    }

}