冒泡排序及其优化

1.初识冒泡排序

1. 冒泡排序（bubble sort)，它是一种基础的交换排序。
2. 思想：把相邻的元素两两比较，当一个元素大于右侧相邻元素时，交换它们的位置，当一个元素小于或等于右侧相邻元素时，位置不变。
3. 待排序序列:
   
   第一轮排序：
   
   第2-7轮各轮排序的结果：
   
4. 冒泡排序是一种稳定的排序，值相等的元素并不会打乱原本的顺序。该排序算法的每一轮都要遍历所有元素，总共遍历（元素数量-1）轮。所以平均时间复杂度为O(n²)。

//双重循环进行排序，外部循环控制所有回合，内部循环实现每一轮的冒泡处理，先进行元素比较在进行元素交换。
public class SortTest {
 
    public static void bubbleSort(int[] array) {
        //-1是因为只需进行array.length-1轮排序
        for (int i = 0; i < array.length-1; i++) {
            //-i是因为每一轮都能确定排序好一个数，减去前面已经排序完的数（有序数列）
            for (int j = 0; j < array.length-i-1; j++) {
            	int temp=0;
                if (array[j] > array[j + 1]) {
                    //交换
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
 
    public static void main(String[] args) {
        int[] array = new int[]{5, 8 ,6, 3, 9, 2, 1, 7};
 
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
}

2.冒泡排序的优化(1)

1. 第6轮排序后就已经是有序的了，可是算法还是进行了第7轮排序.
2. 解决思想：判断出数列已经有序，做出标记，那么剩下的几轮排序就不必执行了。

public class SortTest {
 
    public static void bubbleSort1(int[] array) {
        //-1是因为只需进行array.length-1轮排序
        for (int i = 0; i < array.length - 1; i++) {
            boolean isSorted = true;
            //-i是因为每一轮都能确定排序好一个数，减去前面已经排序完的数（有序数列）
            for (int j = 0; j < array.length - i - 1; j++) {
            	int temp = 0;
                if (array[j] > array[j + 1]) {
                    //交换
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    //元素有交换，说明无序，更改变量值。
                    isSorted = false;
                }
            }
            if (isSorted) {
            	//没有元素交换，数列已经有序，跳出大循环。
                break;
            }
        }
    }
 
    public static void main(String[] args) {
        int[] array = new int[]{5, 8 ,6, 3, 9, 2, 1, 7};
 
        //bubbleSort(array);
        bubbleSort1(array);
        System.out.println(Arrays.toString(array));
    }
}

3.冒泡排序的优化(2)

1. 按照冒泡排序的思想，第1轮只会交换4和2、4和1的位置，第2轮只会交换3和2、3和1的位置，但是右边的许多元素已经是有序的了，第二轮排序时，后面的五个元素的已经是有序的了。因此后面的多次元素比较是没有意义的。
2. 解决思想：可以在每一轮排序后，记录下来最后一次元素交换的位置，该位置为无序数列的边界，再往后就是有序区了。

public class BubbleSort {

    public static void sort(int array[])
    {
        int tmp  = 0;
        //记录最后一次交换的位置
        int lastExchangeIndex = 0;
        //无序数列的边界，每次比较只需要比到这里为止
        //每一轮排序过程中，处于sortBorder之后的元素就不再需要进行比较了，肯定是有序的。
        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])
                {
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    //有元素交换，所以不是有序，标记变为false
                    isSorted = false;
                    //把无序数列的边界更新为最后一次交换元素的位置
                    lastExchangeIndex = j;
                }
            }
            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));
    }
}

4.鸡尾酒排序

• 按照冒泡排序的思想，第1轮只会交换8和1，第2轮只会交换7和1，第3轮只会交换6和1…
  说明的问题是：2-8都是有序的，却要进行7轮排序。

1. 鸡尾酒排序比较和交换的过程是双向的。
   第一轮（和冒泡排序一样，8和1交换）：
   
   第二轮（从右往左）：
   
   第三轮（虽然实际上已经有序，但是流程并没有结束）：

   • 虽然第2轮结束已经有序，但是程序还不知道，因为第2轮进行了交换，需要进行第3轮完全没有交换发生进行确认，才说明已经有序，程序停止。

public class CockTailSort {

    public static void sort(int array[])
    {
        int tmp  = 0;
        for(int i=0; i<array.length/2; i++)
        {
            //有序标记，每一轮的初始是true
            boolean isSorted = true;
            //奇数轮，从左向右比较和交换
            for(int j=i; j<array.length-i-1; j++)
            {
                if(array[j] > array[j+1])
                {
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    //有元素交换，所以不是有序，标记变为false
                    isSorted = false;
                }
            }
            if(isSorted){
                break;
            }

            //偶数轮之前，重新标记为true
            isSorted = true;
            //偶数轮，从右向左比较和交换
            for(int j=array.length-i-1; j>i; j--)
            {
                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[]{2,3,4,5,6,7,8,1};
        sort(array);
        System.out.println(Arrays.toString(array));
    }
}

2. 代码外层的大循环控制着所有排序组合，大循环内包含两个小循环，第一个小循环从左向右比较并交换元素，第二个小循环从右到左比较并交换元素。
3. 鸡尾酒排序：优势：用在大部分元素已经有序的情况下。
   优点：能够在特定条件下，减少排序的回合数
   缺点：代码量几乎增加了一倍。