排序算法---快速排序

什么是快速排序？

快速排序（Quick Sort）是一种高效的排序算法，它使用分治法来将一个数组分成两个子数组，然后对这两个子数组分别进行排序，最后将它们合并成有序的数组。

快速排序的基本步骤：

1. 选择一个基准元素（pivot）：从数组中选择一个元素作为基准元素。通常选择数组的第一个元素或者最后一个元素作为基准元素。

2. 分区（Partition）：将数组中的元素按照基准元素进行分区，比基准元素小的元素放在基准元素的左边，比基准元素大的元素放在基准元素的右边，相同大小的元素可以放在任一边。
   分区过程中，使用两个指针，一个从左往右扫描，一个从右往左扫描，当两个指针相遇时停止。

3. 递归排序：对分区后的两个子数组分别进行快速排序，直到子数组的大小为 1 或 0（已排序），递归结束。

4. 合并：将分区后的两个子数组合并成一个有序的数组，完成排序。

Java实现 1

随机选择一个主元素，大概率会提高效率

class Solution {
    public int[] sortArray(int[] nums) {
        randomizedQuickSort(nums,0,nums.length-1);
        return nums;
    }

    void randomizedQuickSort(int[] nums,int l,int r){
        if(l<r){
            int pos = randomizedPartition(nums,l,r);
            randomizedQuickSort(nums,l,pos-1);
            randomizedQuickSort(nums,pos+1,r);
        }
    }

    int randomizedPartition(int[] nums,int l, int r){
        int i = new Random().nextInt(r-l+1)+l;
        swap(nums,i,r);
        return partition(nums , l ,r);
    }

        int partition(int[] nums,int l,int r){
            int i = l-1;
            int pivot = nums[r];
            for(int j=l;j<r;j++){
                if(nums[j]<=pivot){
                    swap(nums,++i,j);
                }
            }
            swap(nums,++i,r);
            return i;
        }
        
     void swap(int[] nums,int a,int b){
        int temp = nums[a];
        nums[a] = nums[b];
        nums[b] = temp;
    }
}

Java实现 2

每次将最后一个元素作为基准元素

public void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        // 分区，返回基准元素的索引位置
        int pivotIndex = partition(arr, low, high);
        
        // 递归排序左边子数组
        quickSort(arr, low, pivotIndex - 1);
        
        // 递归排序右边子数组
        quickSort(arr, pivotIndex + 1, high);
    }
}

private int partition(int[] arr, int low, int high) {
    // 选择基准元素，通常选择数组的最后一个元素
    int pivot = arr[high];
    
    // 定义一个指针 i，初始化为 low - 1
    int i = low - 1;
    
    // 从 low 遍历到 high - 1
    for (int j = low; j < high; j++) {
        // 如果当前元素小于基准元素，将 i 指针右移，并交换 arr[i] 和 arr[j]
        if (arr[j] < pivot) {
            i++;
            swap(arr, i, j);
        }
    }
    
    // 最后将基准元素放置在正确的位置上（i + 1），即将 arr[i+1] 和 arr[high] 交换
    swap(arr, i + 1, high);
    
    // 返回基准元素的索引位置
    return i + 1;
}

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

快速排序的平均时间复杂度为 O(n log n)，在大多数情况下是最优的排序算法之一。
然而，在最坏情况下，如果基准元素选择不当，可能导致时间复杂度达到 O(n^2)。
为了避免最坏情况，通常可以选择合适的基准元素（如随机选择或者取中位数）来提高快速排序的性能。