Java 快速排序和快速选择算法

快速选择算法（Quickselect），用于在未排序数组中快速找到第k小/大的元素，平均时间复杂度为O(n)

算法核心思想‌

1. ‌基于快速排序分区‌：通过一趟分区将数组分为两部分，左侧≤基准值，右侧≥基准值。
2. ‌递归选择区间‌：根据分区后基准值的位置与k的关系，仅递归处理目标区间。

public class QuickSelect {
    public static int findKthSmallest(int[] nums, int k) {
        if (nums == null || k <= 0 || k > nums.length) 
            throw new IllegalArgumentException("Invalid input");
        return quickSelect(nums, 0, nums.length - 1, k - 1); // 转换为0-based索引
    }

    private static int quickSelect(int[] nums, int left, int right, int k) {
        if (left == right) return nums[left]; // 终止条件
        
        int pivotIndex = partition(nums, left, right);
        if (k == pivotIndex) {
            return nums[k];
        } else if (k < pivotIndex) {
            return quickSelect(nums, left, pivotIndex - 1, k); // 递归左半部分
        } else {
            return quickSelect(nums, pivotIndex + 1, right, k); // 递归右半部分
        }
    }

    private static int partition(int[] nums, int left, int right) {
        int pivot = nums[right]; // 选择最右元素为基准
        int i = left;
        for (int j = left; j < right; j++) {
            if (nums[j] <= pivot) {
                swap(nums, i, j);
                i++;
            }
        }
        swap(nums, i, right); // 将基准放到正确位置
        return i;
    }

    private static void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

    public static void main(String[] args) {
        int[] nums = {3, 2, 1, 5, 6, 4};
        int k = 2; // 找第2小的元素
        System.out.println("第" + k + "小的元素是: " + findKthSmallest(nums, k));
    }
}

代码说明：通过分区和递归缩小范围，快速定位第k小元素，避免完全排序

关键点解析‌

1. ‌分区逻辑‌：partition方法将数组分为两部分，返回基准值的最终位置。
2. ‌递归终止‌：当k等于基准位置时直接返回结果，否则递归处理左/右子数组。
3. ‌时间复杂度‌：平均O(n)，最坏O(n²)（可通过随机化基准值优化）
4. 输入校验‌：检查k是否在有效范围内（1 ≤ k ≤ nums.length）
5. ‌重复元素‌：算法天然支持重复值场景

快速排序算法，采用经典的分治思想，平均时间复杂度为O(n log n)

核心原理‌

1. ‌分区（Partition）‌：选取基准值（pivot），将数组分为左（≤pivot）和右（≥pivot）两部分。
2. ‌递归排序‌：对左右子数组递归执行相同操作，直到子数组长度为1

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

    private static void sort(int[] arr, int left, int right) {
        if (left >= right) return;
        int pivotIndex = partition(arr, left, right);
        sort(arr, left, pivotIndex - 1);  // 递归排序左半部分
        sort(arr, pivotIndex + 1, right); // 递归排序右半部分
    }

    private static int partition(int[] arr, int left, int right) {
        int pivot = arr[right]; // 选择最右元素为基准
        int i = left;
        for (int j = left; j < right; j++) {
            if (arr[j] < pivot) {
                swap(arr, i, j);
                i++;
            }
        }
        swap(arr, i, right); // 将基准放到正确位置
        return i;
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {
        int[] arr = {6, 3, 8, 2, 9, 1};
        quickSort(arr);
        System.out.println(Arrays.toString(arr)); // 输出排序结果-从小到大
    }
}

代码说明：通过分区和递归实现原地排序，空间复杂度O(log n)来自递归栈

关键点解析‌

1. ‌基准选择‌：示例使用最右元素，实际可优化为三数取中或随机选择24。
2. ‌稳定性‌：快速排序是不稳定排序（相同元素可能交换位置）。
3. ‌优化场景‌：小数组可切换为插入排序（如长度≤15）。
4. 最坏情况‌：当数组已有序时退化为O(n²)，需通过随机化基准避免。
5. 大数据优势‌：相比归并排序，快速排序的常量因子更小，实际更快
6. 此实现适用于通用排序场景，是Java标准库Arrays.sort()对基本类型的底层实现之一