排序算法之冒泡排序

冒泡排序应该是最简单的排序算法了。
先说如果有一个数组，int array[] = {43,24,12,56,48,96,100,35,29}; 需要我们升序排列，那么最简单的想法就是说，我们将最大的元素排到最后边。第二大元素排到倒数第二，依次这样算下去就可以，这个过程其实就叫冒泡了….

看看具体代码逻辑怎么样呢？

1. 有多少个元素，我们就要检查多少次。这个是没问题的。
2. 第一次检查，我们把最大的元素依次置换到最右边。
3. 第二次检查，我们把第二大的元素依次置换到倒数第二。并且最后边其实不用检查了。
4. 第三次检查，按照以上的逻辑来做。

依次置换元素怎么做呢？看这个代码。从第一个元素开始，挨个和右边比，只要比右边的大，那么就换位置。这样一趟比下来，最大的肯定在最右边。

for(int i=0;i<args.length-1;i++){
            if(args[i]>args[i+1]){
                int temp = args[i];
                args[i]=args[i+1];
                args[i+1]=temp;
            }
        }

现在需要比较所有的，那就是有多少元素就这样排多少次。完整代码如下。

package com.lenovo.plm.alg;

public class BubbleSort2 {
    public static void main(String[] args) {
        int array[] = {43,24,12,56,48,96,100,35,29};
        sort(array);
    }
    public static void sort(int[] args){
        for(int j=0;j<args.length;j++){
            for(int i=0;i<args.length-1;i++){
                if(args[i]>args[i+1]){
                    int temp = args[i];
                    args[i]=args[i+1];
                    args[i+1]=temp;
                }
            }
        }
        print(args);
    }
    private static void print(int[] args){
        for(int i=0;i<args.length;i++){
            System.out.print(args[i]+",");
        }
    }
}

运行结果不看了，这里可以优化一下，就是其实每一次比较，到最后边其实不用比了，因为前面已经排好了。所以这里可以将里面依次置换的代码调整一下，之前比过多少个元素，那么依次置换时，就跳过那些。
具体实现如下：

package com.lenovo.plm.alg;

public class BubbleSort2 {

    public static void main(String[] args) {
        int array[] = {43,24,12,56,48,96,100,35,29};
        sort(array);
    }

    public static void sort(int[] args){
        for(int j=0;j<args.length;j++){
            for(int i=0;i<args.length-1-j;i++){
                if(args[i]>args[i+1]){
                    int temp = args[i];
                    args[i]=args[i+1];
                    args[i+1]=temp;
                }
            }
        }
        print(args);
    }
    private static void print(int[] args){
        for(int i=0;i<args.length;i++){
            System.out.print(args[i]+",");
        }
    } 
}

这样每次就不用重复比较那些已经排好的了。现在看看还有优化空间，如果每次置换的时候，在最大值往右边移动，最小值往左边移动呢？这样就直接减少一半的元素检查了。

package com.lenovo.plm.alg;

public class CockTailSort {

    public static void main(String[] args) {
        int array[] = {43,24,12,56,48,96,100,35,29};
        sort(array);
    }

    public static void sort(int args[]){
        for(int i=0;i<args.length;i++){
            for(int j=0;j<args.length-1-i;j++){
                if(args[j]>args[j+1]){
                    int temp = args[j];
                    args[j] = args[j+1];
                    args[j+1] = temp;
                }
            }

            for(int j=args.length-1-i;j>i;j--){
                if(args[j]<args[j-1]){
                    int temp = args[j];
                    args[j] = args[j-1];
                    args[j-1] = temp;
                }
            }

        }
        print(args);
    }

    private static void print(int[] args){
        for(int i=0;i<args.length;i++){
            System.out.print(args[i]+",");
        }
    }
}

这样就好了。其实这样做也有个专门的名称，叫做鸡尾酒排序….