交换排序

基本思想：

是两两比较待排序对象的排序码,如发生逆序(即排列顺序与排序后的次序正好相反)，则交换之,直到所有对象都排好序为止。

主要算法：

冒泡排序：BubbleSort
快速排序：QuickSort

冒泡排序

基本思想

设待排序元素序列中的元素个数为 n。最多作 n-1 趟，i = 1, 2, , n-1。在第 i 趟中从后向前，j = n-1, n-2, , i，顺次两两比较V[j-1].key和V[j].key。如果发生逆序，则交换V[j-1]和V[j]。

复杂度和稳定性

时间复杂度：Ω (n)和O(n²)

空间复杂度：O(1)

稳定性：稳定

代码

static void quickSort(int[] nums, int left, int right){
        if (right - left > 1){
            int pos = helper(nums, left, right);
            quickSort(nums, left, pos - 1);
            quickSort(nums, pos + 1, right);
        }
    }

    static int helper(int[] nums, int left, int right){
        int pos = left;
        //从left + 1开始，下标<=pos的是<pivot的数
        int pivot = nums[left];
        for (int i = left + 1; i <= right; i++){
            if (nums[i] < pivot){
                pos++;
                if (pos != i) {
                    int tmp = nums[pos];
                    nums[pos] = nums[i];
                    nums[i] = tmp;
                }
            }
        }
        nums[left] = nums[pos];
        nums[pos] = pivot;
        return pos;
    }

快速排序

基本思想

任取待排序元素序列中的某个元素 (例如取第一个元素) 作为基准，按照该元素的排序码大小，将整个元素序列划分为左右两个子序列：
左侧子序列中所有元素的排序码都小于或等于基准元素的排序码
右侧子序列中所有元素的排序码都大于基准元素的排序码
基准元素则排在这两个子序列中间(这也是该元素最终应安放的位置)。
然后分别对这两个子序列重复施行上述方法，直到所有的元素都排在相应位置上为止。

复杂度和稳定性

时间复杂度：O(nlog₂n)

空间复杂度： O(log₂n)

稳定性：不稳定

代码

static void quickSort(int[] nums, int left, int right) {
        if (right - left > 1) {
            int pos = helper(nums, left, right);
            quickSort(nums, left, pos - 1);
            quickSort(nums, pos + 1, right);
        }
    }

    static int helper(int[] nums, int left, int right) {
        int pos = left;
        //从left + 1开始，下标<=pos的是<pivot的数
        int pivot = nums[left];
        for (int i = left + 1; i <= right; i++) {
            if (nums[i] < pivot) {
                pos++;
                if (pos != i) {
                    int tmp = nums[pos];
                    nums[pos] = nums[i];
                    nums[i] = tmp;
                }
            }
        }
        nums[left] = nums[pos];
        nums[pos] = pivot;
        return pos;
    }

static void quickSort2(int[] nums, int left, int right) {
        if (right - left <= 1) return;

        int pivot = nums[left];
        int l = left + 1;
        int r = right;
        while (true) {
            while (nums[l] < pivot && l < right) l++;
            while (nums[r] >= pivot && r > left) r--;
            if (l >= r) break;
            int tmp = nums[l];
            nums[l++] = nums[r];
            nums[r--] = tmp;
        }
        nums[left] = nums[r];
        nums[r] = pivot;
        quickSort2(nums, left, r - 1);
        quickSort2(nums, r + 1, right);
    }

来源：https://www.cnblogs.com/hao-blogs/p/12633601.html

标签

排序算法