冒泡排序（二次优化版）

package com.jn.learning.algorithm.sort;

import java.util.Arrays;
import java.util.Random;

/***************************************************************************
 * *
 * Written by TankPush (Jn)
 * Description:冒泡排序: 
 * 优化点：
 * 1、一轮内部遍历排序后，查看标志位是否无改变，无改变说明已经有序，则跳出循环
 * 2、一轮遍历排序后，查看当前轮交换元素的位置，记录下来，下次内部循环时，循环到此处即可
 * 
  * 参考网址：https://www.cxyxiaowu.com/5163.html（很不错的算法学习处，推荐）
 * *
 ***************************************************************************/
public class BubbleSort {

    public static void main(String[] args) {

        int[] sourceArr = createArray(10000);
        int[] newArr_V1 = Arrays.copyOf(sourceArr, sourceArr.length);
        int[] newArr_V2 = Arrays.copyOf(sourceArr, sourceArr.length);

        bubbleSort_V1(newArr_V1);
        bubbleSort_V2(newArr_V2);
        Arrays.sort(sourceArr);

        int flagIndex = -1;
        for (int i = 0; i < sourceArr.length; i++) {
            if (sourceArr[i] != newArr_V1[i]) {
                flagIndex = i;
                System.out.println("新数组元素未完成排序，有问题元数索引位置为：" + flagIndex);
            }
        }

        if (flagIndex == -1) {
            System.out.println("新数组完成排序，且无误");
        }

    }

    //一次遍历如未发生元素交换，则已经有序，直接跳出循环
    public static int[] bubbleSort_V1(int[] arr) {

        for (int i = 0; i < arr.length - 1; i++) {

            boolean flag = true;
            for (int j = 0; j < arr.length - 1 - i; j++) {

                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                    flag = false;
                }
            }

            if (flag) {
                break;
            }
        }

        return arr;

    }

    //二次优化
    public static int[] bubbleSort_V2(int[] arr) {

        int sortBorder = arr.length - 1;
        int lastExechangeIndex = 0;
        for (int i = 0; i < arr.length - 1; i++) {

            boolean flag = true;
            for (int j = 0; j < sortBorder; j++) {

                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                    lastExechangeIndex = j;
                    flag = false;
                }
            }

            sortBorder = lastExechangeIndex;
            if (flag) {
                break;
            }
        }

        return arr;

    }


    //交换数组中的元素，必须传入数组，禁止只传入值
    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j]= tmp;
    }

    //随机数组生成器
    public static int[] createArray(int length) {

        int[] arr = new int[length];
        Random random = new Random();

        for (int i = 0; i < length; i++) {
            arr[i] = random.nextInt(length);
        }
        return arr;

    }

}