100道面试必会算法-03-快速排序

100道面试必会算法-03-快速排序

快速排序

给你一个整数数组 nums，请你将该数组升序排列。

示例 1：

输入：nums = [5,2,3,1]
输出：[1,2,3,5]

示例 2：

输入：nums = [5,1,1,2,0,0]
输出：[0,0,1,1,2,5]

快排思路

1. 选择主元（pivot）：从待排序的数组中选择一个元素作为主元。选择主元的方式可以是任意的，常见的方式包括选择第一个元素、最后一个元素、中间元素，或者随机选择一个元素。

2. 分区（Partitioning）：将数组分割成两个子数组，使得左边的子数组中的元素都小于或等于主元，右边的子数组中的元素都大于主元。在分区过程中，需要维护两个指针，一个指针用于遍历数组，另一个指针用于指示当前已确定小于主元的元素的位置。

3. 递归排序子数组：递归地对左右两个子数组进行快速排序。

4. 合并结果：由于快速排序是原地排序算法，排序完成后，数组已经被分成了小于主元和大于主元的两部分，不需要额外的合并操作。

   本人书写残血版（由于固定选取最后一个元素作为主元素，LeetCode排序发生超时）

   import java.util.Arrays;
   
   public class Main {
       // 快速排序算法
       public static void quicksort(int arr[], int left, int right) {
           if (left < right) {
               int prove = arr[right]; // 选择最后一个元素作为主元
               int i = left - 1; // 初始化指针 i
               for (int j = left; j < right; j++) {
                   if (arr[j] < prove) {
                       i++;
                       int temp = arr[j];
                       arr[j] = arr[i];
                       arr[i] = temp; // 交换元素
                   }
               }
               arr[right] = arr[++i]; // 将主元放置到正确的位置
               arr[i] = prove;
               // 递归排序左侧子数组和右侧子数组
               quicksort(arr, left, i - 1);
               quicksort(arr, i + 1, right);
           }
       }
   
       public static void main(String[] args) {
           int a[] = {9, 3, 6, 5, 2, 1, 88, 74, 55, 21, 51, 7};
           int len = a.length; // 计算数组长度
           quicksort(a, 0, len - 1); // 调用快速排序算法进行排序
           // 输出排序后的数组
           for (int i = 0; i < len; i++) {
               System.out.print(a[i] + " ");
           }
       }
   }
   
   

   官方采用随机选取主元素

   class Solution {
       public int[] sortArray(int[] nums) {
           randomizedQuicksort(nums, 0, nums.length - 1);
           return nums;
       }
   
       public 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);
           }
       }
   
       public int randomizedPartition(int[] nums, int l, int r) {
           int i = new Random().nextInt(r - l + 1) + l; // 随机选一个作为我们的主元
           swap(nums, r, i);
           return partition(nums, l, r);
       }
   
       public int partition(int[] nums, int l, int r) {
           int pivot = nums[r];
           int i = l - 1;
           for (int j = l; j <= r - 1; ++j) {
               if (nums[j] <= pivot) {
                   i = i + 1;
                   swap(nums, i, j);
               }
           }
           swap(nums, i + 1, r);
           return i + 1;
       }
   
       private void swap(int[] nums, int i, int j) {
           int temp = nums[i];
           nums[i] = nums[j];
           nums[j] = temp;
       }
   }
   
   

   虽然但是还是喜欢做题时用残血版