常见的排序算法

交换排序

冒泡排序

从小到达排序，每次循环把最大的数移到后面

时间复杂度：

• 平均：O(n²)
• 最好（数组有序）：O(n)

稳定

void bubble(int[] nums) {
    int n = nums.length;
    for (int i = n - 1; i > 0; i--) {
        boolean flag = true;
        for (int j = 0; j < i; j++)
            if (nums[j] > nums[j + 1]) {
                int tmp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = tmp;
                flag = false;
            }
        if (flag) break;
    }
}

快速排序

时间复杂度：

• 平均：O(log₂ⁿ)
• 最差（数组基本有序）：O(n²)

不稳定

每一趟排序至少确定一个元素的最终位置

public static void quickSort(int[] nums, int begin, int end) {
    if (begin >= end) return;
    int first = nums[begin], i = begin, j = end;
    while (i < j) {
        // 这一步可能会导致不稳定, 例如 (0, 2) (1, 1) (2, 1) -> (2, 1) (1, 1) (0, 2)
        while (i < j && nums[j] >= first) --j;
        swap(nums, i, j);
        // 这一步可能会导致不稳定
        while (i < j && nums[i] < first) ++i;
        swap(nums, i, j);
    }
    nums[i] = first;
    quickSort(nums, begin, i - 1);
    quickSort(nums, i + 1, end);
}
public void swap(int[] nums, int i, int j) {
    int tmp = nums[i];
    nums[i] = nums[j];
    nums[j] = tmp;
}

插入排序

直接插入排序

数组的前 i 个元素有序。

时间复杂度：

• 平均：O(n²)
• 最好（数组有序）：O(n)

稳定

每一趟排序不一定能确定元素的最终位置

public void directInsert(int[] nums) {
    int n = nums.length;
    for (int i = 1; i < n; i++) {
        int insertVal = nums[i], j = i - 1;
        for (; j >= 0 && nums[j] > insertVal; j--) nums[j + 1] = nums[j];
        nums[j + 1] = insertVal;
    }
}

希尔排序

时间复杂度：O(n^1.5)

不稳定，例如 (0, 2), (1, 1), (2, 1)，当 k = 2 时，排序的结果为 (2, 1), (1, 1), (0, 2)，两个 1 的相对位置变了。

public void shellSort(int[] nums) {
    int n = nums.length;
    for (int k = n / 2; k > 0; k /= 2) {
        for (int i = k; i < n; i++) {
            int insertVal = nums[i], j = i - k;
            for (; j >= 0 && nums[j] > insertVal; j -= k) nums[j + k] = nums[j];
            nums[j + k] = insertVal;
        }
    }
}

选择排序

简单选择排序

每次选择数组中最小的元素与已排序好的后面一个元素交换

时间复杂度：与数组的初始状态无关，恒为 O(n²)

不稳定，例如 (0, 2), (1, 2), (2, 1)，第一次排序后，(2, 1), (1, 2), (0, 2)

public void simpleChoose(int[] nums) {
    int n = nums.length;
    for (int i = 0; i < n - 1; i++) {
        int min = i;
        for (int j = i + 1; j < n; j++) if (nums[min] > nums[j]) min = j;
        if (min != i) {
            int tmp = nums[i];
            nums[i] = nums[min];
            nums[min] = tmp;
        }
    }
}

堆排序

将数组从小到大排序时，构建大顶堆，每趟把堆顶元素跟已排序的前一个元素交换。

堆是一棵完全二叉树，用数组存储，数组下标从 0 开始，则下标为 i 的结点，左孩子的下标为 2 * i + 1，右孩子的下标为 2 * i + 2，第一个非叶子结点的下标为 n / 2 - 1，其中 n 为数组大小。

时间复杂度：恒为 O(nlogⁿ)

不稳定

public void heap(int[] nums) {
    int n = nums.length;
    for (int i = n / 2 - 1; i >= 0; i--) adjustHeap(i, n, nums);
    for (int i = n - 1; i > 0; i--) {
        // 这一步的交换可能会导致不稳定, 例如 (0, 2), (1, 1), (2, 1), 第一个元素跟最后一个元素交换后, (2, 1), (1, 1), (0, 2)
        int tmp = nums[0];
        nums[0] = nums[i];
        nums[i] = tmp;
        adjustHeap(0, i, nums);
    }
}

private void adjustHeap(int k, int n, int[] nums) {
    int tmp = nums[k];
    for (int i = 2 * k + 1; i < n; i = i * 2 + 1) {
        if (i + 1 < n && nums[i + 1] > nums[i]) ++i;
        if (nums[i] > tmp) {
            nums[k] = nums[i];
            k = i;
        } else break;
    }
    nums[k] = tmp;
}

归并排序

时间复杂度：恒为 O(log₂ⁿ)

递归写法：

int[] tmpArr;

public void divideMerge(int[] nums) {
    int n = nums.length;
    tmpArr = new int[n];
    divide(nums, 0, n - 1);
}

private void divide(int[] nums, int begin, int end) {
    if (begin >= end) return;
    int mid = begin + (end - begin) / 2;
    divide(nums, begin, mid);
    divide(nums, mid + 1, end);
    merge(nums, mid, begin, end);
}

private void merge(int[] nums, int mid, int begin, int end) {
    int i = begin, j = mid + 1, k = 0;
    // 哪个小就先放入到 tmpArr 中, [left, mid] 和 [mid + 1, right] 之间的元素是有序的
    while (i <= mid && j <= end) {
        if (nums[i] <= nums[j]) tmpArr[k++] = nums[i++];
        else tmpArr[k++] = nums[j++];
    }
    // 以下两个只会执行其中一个
    while (i <= mid) tmpArr[k++] = nums[i++];
    while (j <= end) tmpArr[k++] = nums[j++];
    k = 0;
    int size = end - begin + 1;
    while (k < size) nums[begin++] = tmpArr[k++];
}

迭代写法：

public void mergeSort(int[] nums) {
    int n = nums.length;
    tmpArr = new int[n];
    for (int k = 1; k < n; k *= 2) {
        int i = 0;
        while (i + 2 * k - 1 < n) {
            merge(nums, i, i + k - 1, i + 2 * k - 1);
            i += 2 * k;
        }
        if (i + k - 1 < n - 1) merge(nums, i, i + k - 1, n - 1);
    }
}

桶排序

构造有序的桶，然后把元素放入桶中，在桶中排序，最后输出就是有序的

时间复杂度：O(n)

public static void tong(int[] nums) {
    int min = Integer.MAX_VALUE;
    int max = Integer.MIN_VALUE;
    for (int num : nums) {
        min = Math.min(min, num);
        max = Math.max(max, num);
    }
    int bucketSize = (int)Math.ceil((double)(max - min) / nums.length);
    List<List<Integer>> bucket = new ArrayList<>(bucketSize);
    for (int i = 0; i < bucketSize; i++) bucket.add(new ArrayList<>());
    for (int num : nums) {
        int index = (num - min) / nums.length;
        bucket.get(index).add(num);
    }
    int index = 0;
    for (List<Integer> list : bucket) {
        if (list.isEmpty()) continue;
        Collections.sort(list);
        for (int num : list) nums[index++] = num;
    }
}