JAVA基础之冒泡排序大法

转自：3jin博客

        早上上班路上看到有人分享一些Java知识点，由于好学又好奇的话点开看了看，发现第一个推荐是Java冒泡排序算法，说实话这个是Java中不难的基础算法题，理解其中靠推也是可以推出来的，鄙人算是记忆力差的，哈哈，每次面试时让写这个算法基本上是靠当场推断的，但是如果可以还是记住的比较好点(毕竟面试的脑力要留着跟面试官侃侃而谈嘛），现在也算是温故知新嘛。

      这次的原作者给出了3个冒泡排序方法，其中第一种是基本的，然而原作者又在之基础上做了优化，说明原作者比较喜欢研究，向你学习，具体代码如下。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 
 * 冒泡排序.
 *
 */
public final class Test1 {

    private static final Logger LOGGER = LoggerFactory.getLogger(Test1.class);

    /**
     * 基本的冒泡排序.
     * @param a 待排序数组
     */
    public static void sort(int[] a) {
        int temp = 0;
        for(int i = a.length - 1; i > 0; i--) {
            for(int j = 0; j < i; j++) {
                if(a[j + 1] < a[j]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }

    /**
     * 优化的冒泡排序1.
     * 当某一趟遍历没有交换，就说明已经遍历好了，就不用再迭代了
     * @param a 待排序数组
     */
    public static void sort1(int[] a) {
        int temp = 0;
        boolean sorted = false;
        for(int i = a.length - 1; i > 0; i--) {
            sorted = false; //初始值设置为未排序
            for(int j = 0; j < i; j++) {
                if(a[j + 1] < a[j]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                    sorted = true; //发生排序时重新设值
                }
            }
            if(!sorted){
                //当经过一次遍历没有发生一次排序, 或者上次排序位置与本次排序位置相同
                break;
            }
        }
    }
    /**
     * 优化的冒泡排序2.
     * 记录每次遍历数据之后交换次序的位置，显然这个位置之后的数据已经有序了不用再排序了。因此通过记录最后发生数据交换的位置就可以确定下次循环的范围了
     * @param a 待排序数组
     */
    public static void sort2(int[] a) {
        int temp = 0;
        int lastChangeLocation; //上次排序发生的位置
        int nowChangeLocation = a.length - 1; //本次排序发生的位置
        for(int i = a.length - 1; i > 0; i--) {
            lastChangeLocation = nowChangeLocation;
            for(int j = 0; j < i; j++) {
                if(a[j + 1] < a[j]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                    nowChangeLocation = j; //发生排序时重新设值
                }
            }
            if(lastChangeLocation == nowChangeLocation){
                //当经过一次遍历没有发生一次排序, 或者上次排序位置与本次排序位置相同
                break;
            }
        }
    }



    public static void main(final String[] args){
//        int[] a = {0, 1, 2, 3, 4, 5, 6};
        int[] a = {1, 0, 2, 3, 4, 5, 6};
//        int[] a = {0, 6, 2, 3, 4, 5, 1};
//        int[] a = {6, 5, 4, 3, 2, 1, 0};
        LOGGER.info("原数组:{}", a);
        sort2(a);
        LOGGER.info("现数组:{}", a);
    }
}