冒泡排序

在github上看到了一个非常好的项目，用动画来解释十大排序算法，非常便于理解，准备边学习边记录下来，便于日后复习。附上原文链接：https://github.com/MisterBooo/Article

1 算法步骤　　　　

　　设数组长度为N，需要按照从小到大排列

　　1）比较相邻的前后二个数据，如果前面数据大于后面的数据，就将二个数据交换；

　　2）这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置；

　　3）N=N-1，如果N不为0就重复前面二步，否则排序完成。　　

2 动画演示

　　

3 参考代码

package com.tcxpz.sort1;
/**
 * 冒泡排序算法
 * @author jgp QQ:1072218420
 *
 */
public class BubbleSort1{
    public static void main(String[] args) {
        int[] arr = new int[]{5,4,2,3,8};
        System.out.print("排序前：");
        for(int num:arr)
            System.out.print(num+" ");
        System.out.println();
        //进行排序
        int[] bubble_arr = sort(arr);
        System.out.print("排序后：");
        for(int num:bubble_arr)
            System.out.print(num+" ");
    }
    //冒泡排序算法
    private static int[] sort(int[] arr) {
        for (int i=1;i<arr.length;i++) {
            for(int j=0;j<arr.length-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        return arr;
    }       
}

 4 算法改进

　　上面的算法很明显存在一个问题：不管给你一个什么样的数组（假设长度为n），你都要比较n(n-1)/2次。即使该数组已经有序，你也要比较n次。下面对其进行优化，设置一个标志，如果这一趟发生了交换，则为true，否则为false。明显如果有一轮循环没有发生交换，说明排序已经完成。　　　

package com.tcxpz.bubble;
/**
 * 冒泡排序算法的改进
 * 针对这个数组
 * 第一次循环后： 4 2 3 5 8  flag=flase;
 * 第二次循环后： 2 3 4 5 8  flag=false;
 * 第三次循环后： 2 3 4 5 6  flag=true; 跳出循环，返回数组
 * @author jgp QQ:1072218420
 *
 */
public class BubbleSort2{
    public static void main(String[] args) {
        int[] arr = new int[]{5,4,2,3,8};
        System.out.print("排序前：");
        for(int num:arr)
            System.out.print(num+" ");
        System.out.println();
        //进行排序
        int[] bubble_arr = sort(arr);
        System.out.print("排序后：");
        for(int num:bubble_arr)
            System.out.print(num+" ");
    }
    //冒泡排序算法
    private static int[] sort(int[] arr) {
        boolean flag =true;
        while(flag){
            flag = false;
            for(int j=1;j<arr.length;j++){
                if(arr[j-1]>arr[j]){
                    int temp = arr[j-1];
                    arr[j-1] = arr[j];
                    arr[j] = temp;
                    flag=true;
                }
            }
        }
        return arr;
    }       
}

　　再做进一步的优化。如果有100个数的数组，仅前面10个无序，后面90个都已排好序且都大于前面10个数字，那么在第一轮遍历后，最后发生交换的位置必定小于10，且这个位置之后的数据必定已经有序了，记录下这位置，第二次只要从数组头部遍历到这个位置就可以了。　

package com.tcxpz.bubble;
/**
 * 冒泡排序算法的改进
 * @author jgp QQ:1072218420
 *
 */
public class BubbleSort3{
    public static void main(String[] args) {
        int[] arr = new int[]{5,4,2,3,8,9,10,11,12,13,14,15,16,17,18};
        System.out.print("排序前：");
        for(int num:arr)
            System.out.print(num+" ");
        System.out.println();
        //进行排序
        int[] bubble_arr = sort(arr);
        System.out.print("排序后：");
        for(int num:bubble_arr)
            System.out.print(num+" ");
    }
    //冒泡排序算法
    private static int[] sort(int[] arr) {
        int flag= arr.length;
        while(flag>0){
            int k = flag;
            flag = 0;
            for (int j=1;j<k;j++){
                if(arr[j-1]>arr[j]){
                    int temp = arr[j-1];    
                    arr[j-1] = arr[j];
                    arr[j] = temp;
                    flag = j;        //记住最后交换的位置
                }
            }
        }
        return arr;
    }       
}