数据结构---冒泡排序

算法思想

把相邻的元素两两比较，当一个元素大于右侧相邻元素时，交换它们的位置；当一个元素小于或等于右侧相邻元素时，位置不变。

每次冒泡，就把当前最大的元素弄出来了。。。

冒泡排序是一种稳定排序，值相等的元素并不会打乱原本的顺序。由于该排序\算法的每一轮都要遍历所有元素，总共遍历（元素数量-1）轮，所以平均时间复杂度是O(n²)。

代码实现

使用双循环进行排序。外部循环控制所有的回合，内部循环实现每一轮的冒泡处理，先进行元素比较，再进行元素交换。

    public static void sort(int array[]){
        for (int i=0;i<array.length-1;i++){
            for (int j=0;j<array.length-1-i;j++){
                int tmp = 0;
                //大的元素向右挪动
                if(array[j]>array[j+1]){
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                }
            }
        }
    }

优化冒泡排序1

如果能判断出数列已经有序，并做出标记，那么剩下的几轮排序就不必执行了，可以提前结束工作。

代码优化如下：利用布尔变量isSorted作为标记。如果在本轮排序中，元素有交换，则说明数列无序；如果没有元素交换，则说
明数列已然有序，然后直接跳出大循环。

package mysort.bubbleSort;

import java.util.Arrays;

public class bubbleSort2 {

    public static void sort(int array[]){
        for (int i = 0;i<array.length-1;i++){
            //有序标记，每一轮的初始值都是true
            boolean isSorted = true;
            for (int j = 0;j<array.length-1-i;j++){
                int tmp = 0;
                //大元素向后挪
                if(array[j]>array[j+1]){
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    //因为有元素进行交换，所以不是有序的，标记变为false
                    isSorted = false;
                }
            }
            //一旦在一轮中没有元素交换了，说明之后的都有序了，就调出大循环
            //也就是：剩下的几轮排序就不必执行了，可以提前结束工作
            if(isSorted){
                break;
            }
        }
    }

    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));
    }
}

优化冒泡排序2

这个数列的特点是前半部分的元素（3、4、2、1）无序，后半部分的元素（5、6、7、8）按升序排列，并且后半部分元素中的最小值也大于前半部分元素的最大值。

问题在于：其实右面的许多元素已经是有序的了，可是每一轮还是白白地比较了许多次。

按照现有的逻辑，有序区的长度和排序的轮数是相等的。例如第1轮排序过后的有序区长度是1，第2轮排序过后的有序区长度是2 ……实际上，数列真正的有序区可能会大于这个长度，如上述例子中在第2轮排序时，后面的5个元素实际上都已经属于有序区了。因此后面的多次元素比较是没有意义的。

解决方案：我们可以在每一轮排序后，记录下来最后一次元素交换的位置，该位置即为无序数列的边界，再往后就是有序区了。

package mysort.bubbleSort;

import java.util.Arrays;

public class bubbleSort3 {
    public static void sort(int array[]){
        //记录最后一次交换的位置
        int lastExchangeIndex = 0;
        //无序数列的边界，每次比较只需要比到这里为止
        int sortBorder = array.length - 1;
        for (int i =0;i<array.length-1;i++){
            //有序标记，每一轮的初始值都是true
            boolean isSorted = true;
            for (int j = 0;j<sortBorder;j++ ){
                int tmp = 0;
                System.out.println("执行一次比较");
                //大元素后移
                if(array[j]>array[j+1]){
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    //执行到这一步，说明有元素交换，所以不是无序，把标记isSorted置false
                    isSorted = false;
                    //更新为最后一次交换元素的位置
                    // 用于解决右面的许多元素已经是有序的了，可是每一轮中还是白白地比较了许多次的问题
                    lastExchangeIndex = j;
                }
            }
            //之前没有优化的代码里面是：array.length-1-i（这样就可以缩短每轮中比较的长度）
            sortBorder = lastExchangeIndex;
            //如果已经有序，直接跳出，减少比较轮次
            if(isSorted){
                break;
            }

        }
    }



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

    }
}

用没优化的冒泡排序代码如下：

    public static void sort2(int array[]){
        for (int i=0;i<array.length-1;i++){
            for (int j=0;j<array.length-1-i;j++){
                int tmp = 0;
                //大的元素向右挪动
                System.out.println("执行一次比较");
                if(array[j]>array[j+1]){
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;

                }
            }
        }
    }

sortBorder就是无序数列的边界。在每一轮排序过程中，处于sortBorder之后的元素就不需要再进行比较了，肯定是有序的。