排序算法

排序算法时间复杂度分析

名称	英文名	平均时间复杂度	最坏时间复杂度	最好时间复杂度	空间复杂度	稳定性
选择排序	Selectionn	$n^{2}$	$n^{2}$	$n^{2}$	1	不稳定
冒泡排序	Bubble	$n^{2}$	$n^{2}$	$n$	1	稳定
插入排序	Insertion	$n^{2}$	$n^{2}$	$n$	1	稳定
堆排序	heap	$nlog_2n$	$nlog_2n$	$nlog_2n$	1	不稳定
希尔排序	Shell	$n^{1.3}$	$n^{2}$	$n$	1	不稳定
归并排序	Merge	$nlog_2n$	$nlog_2n$	$nlog_2n$	$n$	稳定
快速排序	Quick	$nlog_2n$	$n^{2}$	$nlog_2n$	$log_2n$	不稳定
桶排序	Bucket	$n+k$	$n^{2}$	$n$	$n+k$	稳定
计数排序	Counting	$n+k$	$n+k$	$n+k$	$n+k$	稳定
基数排序	Radix	$n*k$	$n*k$	$n*k$	$n+k$	稳定

冒泡排序

public static void bubbleSort(int[] nums) {
    for (int i = 0; i < nums.length; i++) {
        for (int j = i + 1; j < nums.length; j++) {
            if (nums[i] > nums[j]) {
                int temp = nums[i];
                nums[i] = nums[j];
                nums[j] = temp;
            }
        }
    }
}

public static void main(String[] args) {
    int nums = [4, 1, 3, 6, 2, 7, 9];
     bubbleSort(nums);
}

归并排序

public static void mergeSort(int[] array) {
    if (array == null || array.length < 2) return;   // 数组长度为1时是有序的
    mergeSort(array, 0, array.length - 1);
}

public static void mergeSort(int[] array, int left, int right) {
    if (left == right) return;              // 递归出口
    int mid = (left + right) / 2;
    mergeSort(array, left, mid);            // 拆分左侧数组
    mergeSort(array, mid + 1, right);   // 拆分右侧数组
    merge(array, left, mid, right);
}

public static void merge(int[] array, int left, int mid, int right) {
    int[] temp = new int[right - left + 1];     // 存放归并结果
    int i = 0;
    int p1 = left, p2 = mid + 1;                // P1拆分的左侧数组，P2拆分的右侧数组
    while (p1 <= mid && p2 <= right)            // 两个数组都没有遍历完
        temp[i++] = array[p1] < array[p2] ? array[p1++] : array[p2++];

    while (p1 <= mid) temp[i++] = array[p1++];
    while (p2 <= right) temp[i++] = array[p2++];

    for (i = 0; i < temp.length; i++)
        array[left + i] = temp[i];
}

public static void main(String[] args) {

    int[] nums = {3, 1, 5, 7, 2, 9, 12, 6};
    mergeSort(nums);
}

快速排序

public static void quickSort(int[] nums) {
    if (null == nums || nums.length < 2) return;
    quickSort(nums, 0, nums.length - 1);
}

public static void quickSort(int[] nums, int left, int right) {
    if (left < right) {		 	  // 递归出口
        int pivot = nums[left];    // 基准值
        int L = left, R = right;
        while (L < R) {
            while (nums[R] > pivot && L < R) R--;   // 从右向左找
            if (L < R) {
                nums[L] = nums[R];
                L ++;
            }
            while (nums[L] < pivot && L < R) L ++;  // 从左向右找
            if (L < R) {
                nums[R] = nums[L];
                R --;
            }
        }
        nums[L] = pivot;        // 找到了pivot的位置
        quickSort(nums, left, L - 1);
        quickSort(nums, L + 1, right);
    }
}

其他待补充