常见排序算法

交换方法

    public static void swap(int[] nums, int a, int b) { // 交换数组中的两个数
        int tmp = nums[a];
        nums[a] = nums[b];
        nums[b] = tmp;
    }

 

冒泡排序

    public static void bubbleSort(int[] nums) { // 冒泡排序
        int tmp;
        for (int i = nums.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (nums[j] > nums[j + 1]) {
                    swap(nums, j, j + 1);
                }
            }
        }
    }

 冒泡排序时间复杂度为O(n²)，并且涉及到多次交换（在查找排序中有改进），效率很低。

快速排序

    public static void quickSort(int[] nums, int left, int right) { // 快速排序
        if (left >= right) return;
        int tmp = nums[left];
        int l = left, r = right;
        while (l < r) {
            while (nums[r] >= tmp && l < r) {
                r--; // 右指针先移动
            }
            while (nums[l] <= tmp && l < r) {
                l++; // 左指针后移动
            }
            if (l != r) {
                swap(nums, l, r); // 交换左右指针位置上的数
            }
        }
        swap(nums, left, r);
        quickSort(nums, left, r - 1);
        quickSort(nums, r + 1, right);
    }

快速排序平均时间复杂度为O(nlogn)，效率高但不稳定，当数组有序时，时间复杂度为O(n²)。

 归并排序

    public static void mergeSort(int[] nums, int left, int right) { // 归并排序
        if (left >= right) return;
        int mid = left - (left - right) / 2;
        mergeSort(nums, left, mid);
        mergeSort(nums, mid + 1, right);
        // 创建辅助数组 创建指针
        int[] tmp = new int[right - left + 1];
        int l = left, r = mid + 1, t = 0;
        // 两组中放满一组
        while (l <= mid && r <= right) {
            if (nums[l] < nums[r]) {
                tmp[t] = nums[l];
                l++;
                t++;
            }else {
                tmp[t] = nums[r];
                r++;
                t++;
            }
        }
        // 处理没放完的
        if (l > mid) {
            while (r <= right) {
                tmp[t] = nums[r];
                r++;
                t++;
            }
        }else if (r > right) {
            while (l <= mid) {
                tmp[t] = nums[l];
                l++;
                t++;
            }
        }
        // 最后将tmp数组中排序了的数放入原数组中
        for (int n : tmp) {
            nums[left] = n;
            left++;
        }
        
    }

 

简化：

    public static void mergeSort(int[] nums, int left, int right) { // 归并排序
        if (left >= right) return;
        int mid = left - (left - right) / 2;
        mergeSort(nums, left, mid);
        mergeSort(nums, mid + 1, right);
        // 创建辅助数组 创建指针
        int[] tmp = new int[right - left + 1];
        int l = left, r = mid + 1, t = 0;
        // 两组中放满一组
        while (l <= mid && r <= right) {
            if (nums[l] < nums[r]) {
                tmp[t++] = nums[l++];
            }else {
                tmp[t++] = nums[r++];
            }
        }
        // 处理没放完的
        if (l > mid) {
            while (r <= right) tmp[t++] = nums[r++];
        }else if (r > right) {
            while (l <= mid) tmp[t++] = nums[l++];
        }
        // 最后将tmp数组中排序了的数放入原数组中
        for (int n : tmp) {
            nums[left] = n;
            left++;
        }
        
    }

归并排序的时间复杂度非常稳定，为O(nlogn)，空间复杂度为O(n)。

 堆排序

    public static void heapSort(int[] nums) { // 堆排序
        int size = nums.length;
        // 初始化堆
        for (int i = 0; i < size; i++) {
            while (i > 0) {
                int j = (i - 1) / 2;
                if (nums[i] < nums[j]) break; // 比父节点小则退出循环
                swap(nums, i, j);
                i = j; // 继续向上比较
            }
        }
        // 交换首尾
        swap(nums, 0, size - 1);
        size--;
        // 循环（重建堆，交换首尾）
        while (size > 1) {
            int i = 0;
            while (i * 2 + 1 < size) { // 至少存在左子节点
                int j = i * 2 + 1;
                if (j + 1 < size) { // 两个子节点同时存在
                    if (nums[i] < nums[j] || nums[i] < nums[j + 1]) { // 有一个子节点比父节点大
                        int k = nums[j] > nums[j + 1] ? j : j + 1;
                        swap(nums, i, k);
                        i = k;
                    }else { // 两个子节点都比父节点小
                        break;
                    }
                }else if (nums[i] < nums[j]) { //左子节点比父节点大
                    swap(nums, i, j);
                    i = j;
                }else { // 左子节点比父节点小
                    break;
                }
            }
            swap(nums, 0, size - 1);
            size--;
        }
    }

 堆排序中，初始化堆的时间复杂度为O(n)，重建堆的时间复杂度为O(nlogn)。