排序算法

1. 冒泡排序

时间复杂度：
空间复杂度:

/**
 * 第一次：0 ~ n-1 排序 最大的交换到n-1位上
 * 第二次：0 ~ n-2 排序 最大的交换到n-2位上
 * 第三次：0 ~ n-3 排序 最大的交换到n-3位上
 * 第四次：0 ~ n-4 排序 最大的交换到n-4位上
 * ......
 * 【将最大的数依次移动到最右边】
 */
public static void bubbleSort(int[] arr) {
    if(arr == null || arr.length < 2){
        return;
    }

    for(int end = arr.length - 1;  end > 0; end--){
        for(int i = 0; i < end; i++){
            if(arr[i] > arr[i + 1]){
                swap(arr, i, i + 1);
            }
        }
    }
}

public static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

2.选择排序

时间复杂度:
空间复杂度：

/**
 * 第一次：0 ~ n-1 排序 最小的交换到0位上
 * 第二次：1 ~ n-1 排序 最小的交换到1位上
 * 第三次：2 ~ n-1 排序 最小的交换到2位上
 * 第四次：3 ~ n-1 排序 最小的交换到3位上
 * ......
 * 【将最小的数依次移动到最左边】
 */
public static void selectionSort(int[] arr) {
    if(arr == null || arr.length < 2){
        return;
    }
    
    for(int i = 0; i < arr.length - 1; i++){
        int minIndex = i;
        for(int j = i + 1; j < arr.length; j++) {
            minIndex = arr[j] < arr[minIndex] ? j : minIndex; 
        }
        swap(arr, i, minIndex);
    }
}

public static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

3. 插入排序

时间复杂度：
空间复杂度：

/**
 * 0 ~ 1 排序
 * 0 ~ 2 排序
 * 0 ~ 3 排序
 * 0 ~ n 排序
 * 【依次在0~n之间进行排序】
 */
public static void insertSort(int[] arr) {
   if(arr == null || arr.length < 2){
       return;
   }
   
   for(int i = 1; i < arr.length; i++){
       for(int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--){
           swap(arr, j, j + 1);
       }
   }
}

public static void swap(int[] arr, int i, int j) {
   int temp = arr[i];
   arr[i] = arr[j];
   arr[j] = temp;
}