排序算法

冒泡排序

public static void bubbleSort(int[] arr){
    // 冒泡排序 时间复杂度为O（n^2）
    int temp = 0;   // 临时变量
    boolean flag = false;   // 标识变量，表示是否进行过较换
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 1 - i; j++) {
            // 如果前面的数比后面的大，则较换
            if(arr[j]>arr[j+1]){
                flag = true;
                temp = arr[i];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        if(!flag){   // 在一趟排序中，一次较换都没有发生过
            break;
        }else {
            flag = false; // 重置 falg，进行下次判断
        }
    }
}

选择排序：

public static void selectSort(int[] arr){
    // 选择排序时间复杂度为 O（n^2）
    for (int i = 0; i < arr.length - 1; i++) {
        int minIndex = i;
        int min = arr[i];
        for (int j = 0; j < arr.length; j++) {
            if(min>arr[j]){ // 说命假定的最小值，并不是最小
                min = arr[j];  // 重复min
                minIndex = j;   // 重置 minIndex
            }
        }
        // 将最小值，放在arr[0]， 即较换
        if(minIndex != i){
            arr[minIndex] = arr[i];
            arr[i] = min;
        }
    }
}

插入排序：

// 插入排序
    public static void insertSort(int[] arr) {
        int insertVal = 0;
        int insertIndex = 0;
        // 使用for循环来把代码简化
        for (int i = 0; i < arr.length; i++) {
            // 定义待插入的数
            insertVal = arr[i];
            insertIndex = i - 1;    // 即arr[1]得前面这个数得下标

            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            // 这里我们判断是否需要赋值
            if (insertIndex + 1 != i) {
                arr[insertIndex + 1] = insertVal;
            }
        }
    }

快速排序：

public static void quickSort(int[] arr,int left,int right){
        int l = left;   // 左下标
        int r = right;  // 右下标
        // pivot 中间值
        int pivot = arr[(left + right) / 2];
        int temp = 0;   // 临时变量，作为较换时使用
        // while循环得目的时让比pivot值小得放到左边
        // 比 pivot 值大得放到右边
        while (l<r){
            // 在 pivot 的左边一直找，找到大于等于pivot值，才退出
            while (arr[l]<pivot){
                l += 1;
            }
            // 在pivot 的右边一直找，找到小于 pivot 值，才退出
            while (arr[r]>pivot){
                r -= 1;
            }
            // 如果 l>=r说命pivot的左右两个值，已经按照左边全都是
            // 小于等于pivot值，右边全部都是大于等于pivot值
            if(l>=r){
                break;
            }
            // 交换
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
            // 如果交换完后，发现这个arr[l] == pivot 值 相等 r--，前移
            if(arr[l] == pivot){
                r -= 1;
            }
            // 如果交换完后，发现这个arr[r] == pivot 值 相等 l++,后移
            if(arr[r] == pivot){
                l += 1;
            }
            // 如果 l == r 必须 l++,r--，否则为出现栈溢出
            if(l == r){
                l += 1;
                r -= 1;
            }
            // 向左递归
            if(left < r){
                quickSort(arr,left,r);
            }
            // 向右递归
            if(right > l){
                quickSort(arr,l,right);
            }
        }
    }