线性时间选择算法（Linear Time Selection, Quickselect）详细解读

最新推荐文章于 2024-12-11 21:52:54 发布

Katie。

最新推荐文章于 2024-12-11 21:52:54 发布

阅读量1.8k

点赞数 10

分类专栏：算法分析文章标签：算法

本文链接：https://blog.csdn.net/m0_61840987/article/details/143226718

版权

算法分析专栏收录该内容

87 篇文章

订阅专栏

线性时间选择算法（Linear Time Selection），通常称为 Quickselect，是一种用于在无序数组中选择第 k 小元素的高效算法。它的平均时间复杂度是 O(n)，最坏情况下为 O(n²)，但通过优化可以降低最坏情况的发生概率。Quickselect 基于快速排序（Quicksort）算法的分治思想，是一种不需要对数组进行完全排序的选择算法。

1. Quickselect 的基本思想

Quickselect 的核心思想与快速排序相似。它通过递归地选择一个基准值（pivot），将数组划分为两部分，并根据 k 的位置确定继续在哪一部分中查找。

具体过程：

选择基准值：随机选择数组中的一个元素作为基准值。
分区操作：将数组划分为两部分，所有小于基准值的元素放在左侧，所有大于基准值的元素放在右侧。
判断 k 的位置：
- 如果基准值的位置正好是 k（即数组中第 k 小的元素），则找到目标元素。
- 如果 k 在基准值的左侧部分，继续递归在左侧部分查找。
- 如果 k 在基准值的右侧部分，继续递归在右侧部分查找。

由于每次递归都会缩小查找的范围，最终会在平均 O(n) 时间内找到第 k 小的元素。

2. Quickselect 算法的步骤

假设我们要在数组 arr 中查找第 k 小的元素（1-based 索引，即第 1 小的元素是最小值），具体步骤如下：

选择基准值：随机选择一个元素作为基准值。
分区操作：将数组根据基准值分成两部分，左边是小于基准值的元素，右边是大于基准值的元素。
递归查找：
- 如果基准值的位置等于 k - 1，则返回基准值作为第 k 小的元素。
- 如果基准值的位置大于 k - 1，递归在左侧部分查找。
- 如果基准值的位置小于 k - 1，递归在右侧部分查找。

3. Quickselect 的 Java 实现

下面是 Quickselect 算法的 Java 实现：

import java.util.Random;

public class Quickselect {

    // 主函数，找到数组中第 k 小的元素
    public static int quickselect(int[] arr, int k) {
        return quickselectHelper(arr, 0, arr.length - 1, k - 1);  // k-1 表示转化为 0-based 索引
    }

    // 辅助函数，递归进行分区和查找
    private static int quickselectHelper(int[] arr, int left, int right, int k) {
        if (left == right) {  // 如果数组只有一个元素，直接返回
            return arr[left];
        }

        // 选择基准值，并进行分区操作
        int pivotIndex = partition(arr, left, right);

        // 根据 pivotIndex 和 k 的位置来判断是否找到第 k 小元素
        if (k == pivotIndex) {
            return arr[k];  // 如果基准值正好是第 k 小的元素
        } else if (k < pivotIndex) {
            return quickselectHelper(arr, left, pivotIndex - 1, k);  // 在左侧递归查找
        } else {
            return quickselectHelper(arr, pivotIndex + 1, right, k);  // 在右侧递归查找
        }
    }

    // 分区操作：将数组根据基准值分为两部分
    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 = {3, 2, 1, 5, 6, 4};
        int k = 2;
        System.out.println("The " + k + "th smallest element is: " + quickselect(arr, k));
    }
}

代码解读

quickselect 函数：主函数，用户调用时传入数组和 k 值，内部调用递归函数 quickselectHelper。注意，这里将 k 转化为 0-based 索引，即 k - 1。
quickselectHelper 函数：递归函数，通过不断分区找到第 k 小的元素。如果 left == right，即数组只有一个元素，则直接返回这个元素。
partition 函数：分区函数，选择数组最右边的元素作为基准值，并根据基准值将数组划分为两部分，所有小于基准值的元素在左侧，大于基准值的在右侧。返回基准值的最终位置。
swap 函数：用于交换数组中的两个元素。
主函数测试：对于数组 [3, 2, 1, 5, 6, 4]，查找第 2 小的元素，输出为 2。

4. Quickselect 的时间复杂度

平均时间复杂度：Quickselect 的平均时间复杂度为 O(n)，其中 n 是数组的长度。原因在于，每次分区后只需要递归处理数组的一半，类似于二分法，但不需要完全排序。
最坏时间复杂度：最坏情况是每次选择的基准值都是数组中的最小或最大值，导致每次只减少一个元素。此时算法的时间复杂度退化为 O(n²)，类似于快速排序的最坏情况。

5. 优化 Quickselect 的方法

为了减少最坏情况发生的概率，可以对基准值的选择进行优化：

随机选择基准值：可以随机选择数组中的一个元素作为基准值，而不是总是选择最右边的元素。这种随机化基准值的策略能够有效地避免最坏情况，通常在实现中使用。
Median of Medians 算法：通过对数组进行分组，选择每组的中位数，再从这些中位数中选择一个作为基准值。这种方法能确保基准值接近于中位数，最坏情况下的时间复杂度可以保证为 O(n)。