排序算法（1）冒泡排序

一. 基本思想

冒泡排序的基本思想是，对相邻的元素进行两两比较，如果前一个比后一个大，则交换位置，这样每一趟就会冒出一个最大的

二.概览

分类： 内部比较排序

数据结构：数组

最差时间复杂度：O（n^2）

最好时间复杂度： O（n）   ---下面的改进版可实现

平均时间复杂度：O（n^2）

稳定性：稳定

三.动图演示

三 .代码实现

（1）原始版

public class Bubble {
    public static void sort(int[] a){
        int N = a.length;
        for(int i = 0;i<N;i++){
            for (int j = 0;j<N-i-1;j++){
                //此处>变成>=就会变成不稳定排序
                if(a[j] > a[j+1]){
                    int tmp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = tmp;
                }
            }
        }
    }
}

（2）改进版1

    可以看出即使给定的是一个有序的序列，仍需要遍历n趟，比较n次。所以可以设计一个标记在第一次循环没有发生交换时（意味着此序列有序）就直接返回。这样最佳时间复杂度变为O（n）

public class Bubble {
    public static void sort(int[] a){
        int N = a.length;
        boolean flag = false;
        for(int i = 0;i<N;i++){
            for (int j = 0;j<N-i-1;j++){
                if(a[j] > a[j+1]){
                    int tmp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = tmp;
                    flag = true;
                }
            }
            if(flag = false){
                return;
            }
        }
    }
}

（3）改进版2

鸡尾酒排序，也叫定向冒泡排序，是冒泡排序的一种改进

与冒泡排序的不同是从低到高再从高到低，而冒泡排序仅是从低到高

public class CocktailSort {
    public static void swap(int a[],int i,int j){
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    public static void sort(int a[]){
        int letf = 0;
        int right = a.length-1;
        while (letf < right) {
            //前半轮，将最大元素放到后面
            for (int i = letf;i < right;i++){
                if(a[i]>a[i+1]){
                    swap(a, i, i+1);
                }
            }
            right--;
            //后半轮,将最小元素放到前面
            for(int j = right;j > letf;j--){
                if(a[j] < a[j-1]){
                    swap(a, j, j-1);
                }
            }
            letf++;
        }
    }
    
}

以序列(2,3,4,5,1)为例，鸡尾酒排序只需要访问一次序列就可以完成排序，但如果使用冒泡排序则需要四次。但是在乱数序列的状态下，鸡尾酒排序与冒泡排序的效率都很差劲。