java排序-冒泡/选择/插入/快速/归并

算法比较： 1）复杂度分析 2）比较和交换次数分析 3）内存分析 4）稳定性分析

//bubbleSort
public static void bubbleSort(int[] nums) {
    for (int i = 0; i < nums.length; i++) {
        for (int j = 0; j < nums.length - i - 1; j++) {
            if (nums[j] > nums[j+1]) {
                int temp = nums[j];
                nums[j] = nums[j+1];
                nums[j+1] = temp;
            }
        }
    }
    for (int i = 0; i < nums.length; i++) {
        for (int j = 1; j < nums.length - i; j++) {
            if (nums[j - 1] > nums[j]) {
                int temp = nums[j - 1];
                nums[j - 1] = nums[j];
                nums[j] = temp;
            }
        }
    }
}
/*
  1.冒泡排序比较相邻位置的两个数，而选择是按顺序比较
  2.冒泡排序每一轮比较后，位置不对都需要换位置，选择每一轮只交换一次
  3.选择排序交换次数较少，一定程度上提高了效率
 */
//selectSort
public static void selectSort(int[] nums) {
    for (int i = 0; i < nums.length; i++) {
        int pos = i;
        for (int j = i + 1; j < nums.length; j++) {
            if (nums[pos] > nums[j]) {
                pos = j;
            }
        }
        if (pos != i) {
            int temp = nums[pos];
            nums[pos] = nums[i];
            nums[i] = temp;
        }
    }
}
//insertSort
public static void insertSort(int[] nums) {
    int insertNode;
    for (int i = 1; i < nums.length; i++) {
        insertNode = nums[i];
        int j = i - 1;
        while (j >= 0 && insertNode < nums[j]) {
            nums[j + 1] = nums[j];
            j--;
        }
        nums[j + 1] = insertNode;
    }
}
public static void sort(int[] nums) {
    quickSort(nums, 0, nums.length - 1);
}
//quickSort
public static void quickSort(int[] nums, int start, int end) {
    if (start >= end) {
        return;
    }
    int pivot = nums[start];
    int left = start;
    int right = end;
    while (left <= right) {
        while (nums[left] < pivot) {
            left++;
        }
        while (nums[right] > pivot) {
            right--;
        }
        if (left <= right) {
            int temp = nums[left];
            nums[left] = nums[right];
            nums[right] = temp;
            left++;
            right--;
        }
    }
    quickSort(nums, start, right);
    quickSort(nums, left, end);
}
/*
    快速插入与归并插入的区别：
    快速插入比较不稳定，而归并插入需要额外空间来操作数组
 */
//mergeSort
public static void mergeSort(int[] nums) {
    if (nums == null || nums.length == 0) {
        return;
    }
    int[] temp = new int[nums.length];
    mergeSortImpl(nums, 0, nums.length - 1, temp);
}
public static void mergeSortImpl(int[] nums, int start, int end, int[] temp) {
    if (start >= end) {
        return;
    }
    int mid = start + (end - start) / 2;
    mergeSortImpl(nums, start, mid, temp);
    mergeSortImpl(nums,mid + 1, end, temp);
    merge(nums, start, mid, end, temp);
}
public static void merge(int[] nums, int start, int mid, int end, int[] temp) {
    int left = start;
    int right = mid + 1;
    int index = start;
    while (left <= mid && right <= end) {
        if (nums[left] <= nums[right]) {
            temp[index++] = nums[left++];
        } else {
            temp[index++] = nums[right++];
        }
    }
    while (left <= mid) {
        temp[index++] = nums[left++];
    }
    while(right <= end) {
        temp[index++] = nums[right++];
    }
    for (int i = start; i <= end; i++) {
        nums[i] = temp[i];
    }
}