改进优化冒泡排序

冒泡排序 ： 以从小到大为例，每一轮排序找出未排序序列中最大值放在最后。

private static int[] bubbleSort(int[] ints) {
    int len = ints.length;
    for (int i = 0; i < len; i++) {
        for (int j = 1; j < len - i; j++) {
            if (ints[j - 1] > ints[j]) {
                int temp = ints[j];
                ints[j] = ints[j-1];
                ints[j-1] = temp;
            }
        }
    }
    return ints;
}

       上面这中是最普通的冒泡排序，如果字符串或者数字串本身一部分存在序列，例如 12345987 其中12345已经排好序列，但是上面这种排序方式还是会进行比较，这样会造成不必要的时间浪费。

        改进方式1：设置一个标志flag，如果发生了数据交换则flag=true，否则为false。

private static int[] bubbleSort1(int[] ints) {
    int len = ints.length;
    boolean flag = true;
    while (flag) {
        flag = false;
        for (int i = 1; i < len; i++) {
            if (ints[i - 1] > ints[i]) {
                int temp = ints[i];
                ints[i] = ints[i-1];
                ints[i-1] = temp;
                flag = true;
            }
        }
        len -- ;
    }
    return ints;
}

        上面这种方式只要排序完成就会推出排序，这种方式已经减少了时间的浪费。假如现在有一个长度10000的数组，前1000无序，后9000有序并且大于前100数据。用上面这种方法，数据交换次数在1000之内，但是剩下9000的数据虽然没有交换，但是每次循环都会进行比较。剩下9000数据已经有序了，我们不要对它们去进行判断浪费不必要的时间。

        改进方式2：还是设置flag，如果进行的数据交换，那么用flag设置边界，这样后面的数据就不会进行判断比较了。

private static int[] bubbleSort2(int[] ints) {
    int len = ints.length;
    int flag = len;
    while (flag>0) {//如果flag>0则排序结束
        flag = 0;
        for (int i = 1; i < len; i++) {
            if (ints[i - 1] > ints[i]) { //前面大于后面则交换数据
                int temp = ints[i];
                ints[i] = ints[i-1];
                ints[i-1] = temp;
                flag = i; //设置最新边界
            }
        }
        len = flag;//记录遍历的边界
    }
    return ints;
}

        测试：用for循环写入10000个数据，前1000倒序排序，后9000顺序排序。

        测试程序：

int[] ints = new int[10000];
//向数组写入10000个数据 前1000倒序 ， 后9000顺序。
for (int i = 0; i < 10000; i++) {
    if (i<=1000) ints[i] = 1000-i;
    else ints[i] = i;
}
System.out.println("排序前：");
System.out.println(Arrays.toString(ints));
System.out.println("排序后：");
//调用3种方式，分别记录运行时间
long startTime = System.currentTimeMillis();//获取当前时间
System.out.println(Arrays.toString(bubbleSort(ints))); // 方式  bubbleSort(ints) 没有经过优化的冒泡
//bubbleSort(ints);
long endTime = System.currentTimeMillis();//获取当前时间
System.out.println("程序运行时间："+(endTime-startTime)+"ms");//两个时间相减 = 程序运行时间

        测试结果：

第一种：bubbleSort

程序运行时间：100ms

第二种：bubbleSort1（测试程序按照第一种，把bubbleSort改为bubbleSort1）

程序运行时间：30ms

第三种：bubbleSort2（测试程序按照第一种，把bubbleSort改为bubbleSort2）

程序运行时间：13ms

        从测试结果可以看出，最后的优化比没有优化快了将近90ms。如果数据量大，差距会更加明显。

        这种方式就是目前改进优化最好的冒泡排序了。