java 冒泡排序// 选择排序

一.冒泡排序

    //冒泡排序
    //思想：两两比较，大的往后走
    //  时间复杂度0（n^2）
    //  空间复杂度 0（1）
    //10w个随机数排序需13s左右。结果不准确/仅供参考
    public static void bubbleSort(int[] array) {
        if (array == null) {
            return;
        }
        boolean nextSort = true;//优化：当数组本来就是有序的。那只进行一轮判断就结束循环，时间复杂度为O（n）空间复杂度不变。
        for (int i = 0; i < array.length - 1 && nextSort; i++) {
            nextSort = false;
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                    nextSort = true;
                }
            }
        }
    }

二. 选择排序。

   //选择排序：
    //思想：选择当前待排须的最小值放到第一个位置 最大值放到最后一个位置
    //时间负责度 0（n^2 ) 空间 0（1）
    //稳定型： 不稳定
    //10w个随机数排序用时2.4s左右。此处仅供参考。
     public static int[] optimizedSelectSort(int[] array) {
        if (array == null || array.length == 0) {
            return null;
        }
        for (int i = 0; i < array.length / 2; i++) {
            int minIndex = i;
            int maxIndex = i;
            for (int j = i + 1; j <= array.length - 1 - i; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                    //continue;
                }
                if (array[j] > array[maxIndex]) {
                    maxIndex = j;
                }
            }
            //minIndex指向的最小值与第一个值进行交换
            int tmp = array[minIndex];
            array[minIndex] = array[i];
            array[i] = tmp;
            // 如果上一步操作把最大值与最小值交换则需最大指向最小值位置
            if (maxIndex == i) {
                maxIndex = minIndex;
            }
            //maxIndex指向的最大值与最后一个值进行交换
            tmp = array[maxIndex];
            array[maxIndex] = array[array.length - 1 - i];
            array[array.length - 1 - i] = tmp;
        }
        return array;
    }