java 快速排序随机选择key

本文介绍了一种改进的快速排序算法实现——随机快速排序,并通过Java代码详细展示了如何使用随机选取枢轴的方式进行数组排序的过程。这种方法能有效减少最坏情况的发生概率,提高排序效率。
import java.util.Arrays;
import java.util.Random;

/***
 * 快速排序随机选择key
 */
public class QuickSortRandom {

    static public void main(String[] args){

        int[] array={9,0,10,-2,5,19,4,0,7,2,22};
        quickSortRandom(array,0,array.length-1);
        System.out.println(Arrays.toString(array));


    }



    static public void quickSortRandom(int[] array,int l,int h){
        if(l>=h)
            return;

        int _l=l;
      int _h=h;
      int keyIndex=new Random().nextInt(h-l) + l;

      int key=array[keyIndex];

      int temp=array[l];
      array[keyIndex]=temp;
      array[l]=key;



      while(_l<_h){

          while(_l<_h&&array[_h]>=key){
              _h--;
          }

          temp=array[_h];
          array[_h]=array[_l];
          array[_l]=temp;


          while(_l<_h&&array[_l]<=key){
              _l++;
          }

          temp=array[_l];
          array[_l]=array[_h];
          array[_h]=temp;

      }

      System.out.println("==");

      if(l<_l){
          quickSortRandom(array,l,_l-1);
      }

      if(_h<h){
          quickSortRandom(array,_h+1,h);
      }



    }

}
<think>我们被要求提供一个Java快速排序算法实现示例。根据引用内容,我们可以参考多个实现。 引用[1]提供了一个Java实现的快速排序,其中主方法为quickSort,分区方法为partition,并选择最后一个元素作为基准。 引用[2]和引用[3]也提到了快速排序的基本原理和实现。 引用[4]和引用[5]则提供了一些优化方法和应用场景。 我们将按照以下步骤实现: 1. 选择一个基准元素(pivot)。可以选择第一个、最后一个、随机一个或者中间值等。 2. 分区(partition):重新排列数组,使得所有小于基准的元素放在基准前面,大于基准的放在后面。分区完成后,基准元素处于其正确位置。 3. 递归地对基准左右两边的子数组进行快速排序。 这里我们采用引用[1]的实现方式,选择最后一个元素作为基准,并实现分区方法。 注意:快速排序有多个版本,我们这里实现的是Lomuto分区方案,另一种常见的分区方案是Hoare分区方案。 我们将编写一个类,包含快速排序的静态方法。 同时,根据引用[5]提到的优化,我们可以考虑: - 随机选取基准(避免最坏情况) - 小序列时使用插入排序(优化递归) - 处理相同元素(三向切分) 但作为基础示例,我们先实现一个基础版本,然后可以再展示一个优化版本(随机基准)。 基础版本(固定基准,选择最后一个元素): 步骤: - 在分区方法中,设置基准为最后一个元素。 - 初始化一个索引i(表示小于基准的最后一个元素的位置),从low-1开始。 - 遍历数组从low到high-1,如果当前元素小于等于基准,则将其与i+1位置的元素交换,并递增i。 - 最后将基准(arr[high])与i+1位置的元素交换,这样基准就放在了正确的位置。 - 返回基准的索引(i+1)。 递归方法: - 如果low小于high,则进行分区,然后递归排序左右两部分。 我们还可以实现一个随机基准的版本,以避免在数组已经有序时出现最坏时间复杂度O(n^2)。 随机基准版本: - 在分区前,随机选择一个位置与最后一个元素交换,然后再以最后一个元素作为基准。 下面我们分别实现这两个版本。 注意:为了清晰,我们提供两个示例:基础版本和随机基准版本。 首先,基础版本:</think>### Java 快速排序算法实现示例 快速排序是一种基于**分治法**的高效排序算法,其核心思想是通过递归地将数组划分为较小和较大的两部分来实现排序。以下是标准实现和优化版本: #### 基础实现(固定基准) ```java public class QuickSort { // 快速排序入口方法 public static void quickSort(int[] arr, int low, int high) { if (low < high) { int pi = partition(arr, low, high); // 获取基准位置 quickSort(arr, low, pi - 1); // 递归排序左子数组 quickSort(arr, pi + 1, high); // 递归排序右子数组 } } // 分区函数(Lomuto方案) private static int partition(int[] arr, int low, int high) { int pivot = arr[high]; // 选择最后一个元素作为基准 int i = low - 1; // 小于基准的边界指针 for (int j = low; j < high; j++) { if (arr[j] <= pivot) { i++; // 交换元素 int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } // 将基准放到正确位置 int temp = arr[i + 1]; arr[i + 1] = arr[high]; arr[high] = temp; return i + 1; } // 测试用例 public static void main(String[] args) { int[] arr = {10, 80, 30, 90, 40, 50, 70}; quickSort(arr, 0, arr.length - 1); System.out.println("排序结果: " + Arrays.toString(arr)); // 输出: [10, 30, 40, 50, 70, 80, 90] } } ``` #### 优化版本(随机基准 + 三数取中) ```java public class OptimizedQuickSort { public static void quickSort(int[] arr, int low, int high) { if (high - low < 16) { // 小数组使用插入排序 insertionSort(arr, low, high); return; } if (low < high) { int pi = randomizedPartition(arr, low, high); quickSort(arr, low, pi - 1); quickSort(arr, pi + 1, high); } } // 随机选择基准 private static int randomizedPartition(int[] arr, int low, int high) { // 三数取中法选择基准 int mid = low + (high - low) / 2; if (arr[mid] < arr[low]) swap(arr, low, mid); if (arr[high] < arr[low]) swap(arr, low, high); if (arr[mid] < arr[high]) swap(arr, mid, high); return partition(arr, low, high); } // Hoare分区方案(减少交换次数) private static int partition(int[] arr, int low, int high) { int pivot = arr[high]; int i = low, j = high - 1; while (true) { while (i <= j && arr[i] < pivot) i++; while (i <= j && arr[j] > pivot) j--; if (i >= j) break; swap(arr, i++, j--); } swap(arr, i, high); return i; } // 插入排序辅助函数 private static void insertionSort(int[] arr, int low, int high) { for (int i = low + 1; i <= high; i++) { int key = arr[i]; int j = i - 1; while (j >= low && arr[j] > key) { arr[j + 1] = arr[j]; j--; } arr[j + 1] = key; } } private static void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } ``` ### 关键特性说明 1. **时间复杂度**: - 平均情况:$O(n \log n)$ - 最坏情况(已排序数组):$O(n^2)$ - 优化后最坏情况概率显著降低[^3] 2. **空间复杂度**: - 递归栈深度:$O(\log n)$(优化后) - 属于**原地排序**算法[^4] 3. **优化策略**: - **随机基准**:避免已排序数组的最坏情况 - **三数取中**:选择更合理的基准值 - **小数组切换**:对长度<16的子数组用插入排序 - **Hoare分区**:减少元素交换次数[^5] ### 适用场景 1. 大规模乱序数组排序(平均性能最优)[^4] 2. 内存敏感场景(原地排序特性) 3. 数据频繁变动的动态数据集[^4] 4. 对稳定性无要求的场景(快速排序不稳定) > ⚠️ 注意:当数据已基本有序时,建议使用插入排序;当需要稳定排序时,建议使用归并排序。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值