算法学习——线性选择

线性选择算法

线性选择算法是一种用于在一个无序数组中查找第k小元素的高效算法。它的时间复杂度为O(n)，比一般的排序算法要快得多。线性选择算法的核心思想是利用快速排序中的分治思想，将数组分成若干个子数组，并递归地处理其中包含第k小元素的那个子数组，直到找到第k小元素。

算法流程

下面是线性选择算法的具体流程：

1. 将数组A分成n/5组，每组包含5个元素（最后一组可能少于5个）。

2. 对于每组元素，使用插入排序算法进行排序。

3. 从每组元素中选择中位数，将这些中位数组成一个新的数组B。

4. 递归调用线性选择算法，查找数组B中的中位数m。

5. 使用快速排序的划分过程，将数组A分成两个部分：左边的元素小于等于m，右边的元素大于m。

6. 如果k小于等于左边部分的元素个数，则递归调用线性选择算法，在左边部分中查找第k小元素。

7. 如果k大于左边部分的元素个数加上右边部分的中位数个数，则递归调用线性选择算法，在右边部分中查找第k-leftCount-middleCount小元素。

8. 否则，返回m作为第k小元素。

下面我们举例说明

假设我们要在数组A={3, 1, 4, 2, 5, 7, 6, 8, 10, 9}中查找第5小的元素。

1. 将数组A分成n/5=2组，每组包含5个元素。分别为{3, 1, 4, 2, 5}和{7, 6, 8, 10, 9}。

2. 对于每组元素，使用插入排序算法进行排序。两组排序后分别为{1, 2, 3, 4, 5}和{6, 7, 8, 9, 10}。

3. 从每组元素中选择中位数，将这些中位数组成一个新的数组B。B中的中位数为5和8。

4. 递归调用线性选择算法，查找数组B中的中位数m。由于B的大小为2，所以m为8。

5. 使用快速排序的划分过程，将数组A分成两个部分：左边的元素小于等于m，右边的元素大于m。分割后左边部分为{3, 1, 4, 2, 5}，右边部分为{7, 6, 8, 10, 9}。

6. 如果k小于等于左边部分的元素个数，则递归调用线性选择算法，在左边部分中查找第k小元素。由于左边部分的大小为5，且k=5，所以我们需要在左边部分中查找第5小的元素。

7. 将左边部分{3, 1, 4, 2, 5}继续分组，每组包含5个元素。分别为{3, 1, 4, 2, 5}。

8. 对于每组元素，使用插入排序算法进行排序。排序后为{1, 2, 3, 4, 5}。

9. 从每组元素中选择中位数，将这些中位数组成一个新的数组B。B中的中位数为3。

10. 递归调用线性选择算法，查找数组B中的中位数m。由于B的大小为1，所以m为3。

11. 使用快速排序的划分过程，将左边部分分成两个部分：左边的元素小于等于m，右边的元素大于m。分割后左边部分为空，右边部分为{4, 5}。

12. 如果k小于等于左边部分的元素个数，则递归调用线性选择算法，在左边部分中查找第k小元素。由于左边部分的大小为0，所以我们需要在右边部分中查找第1小的元素。

13. 将右边部分{4, 5}继续分组，每组包含5个元素。分别为{4, 5}。

14. 对于每组元素，使用插入排序算法进行排序。排序后为{4, 5}。

15. 从每组元素中选择中位数，将这些中位数组成一个新的数组B。B中的中位数为4。

16. 递归调用线性选择算法，查找数组B中的中位数m。由于B的大小为1，所以m为4。

17. 使用快速排序的划分过程，将右边部分分成两个部分：左边的元素小于等于m，右边的元素大于m。分割后左边部分为{4}，右边部分为{5}。

18. 如果k小于等于左边部分的元素个数，则递归调用线性选择算法，在左边部分中查找第k小元素。由于左边部分的大小为1，且k=1，所以我们需要返回左边部分中的最小值4作为第5小的元素。

因此，数组A中第5小的元素为4。

代码

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int linearSelect(vector<int>& nums, int k) {
    if (nums.size() <= 5) {
        sort(nums.begin(), nums.end());
        return nums[k - 1];
    }

    // 将数组分成若干组，每组包含5个元素
    vector<vector<int>> groups;
    for (int i = 0; i < nums.size(); i += 5) {
        groups.push_back(vector<int>(nums.begin() + i, nums.begin() + min(i + 5, (int)nums.size())));
    }

    // 对每组元素进行排序，选出中位数构成新的数组B
    vector<int> medians;
    for (auto& group : groups) {
        sort(group.begin(), group.end());
        medians.push_back(group[group.size() / 2]);
    }

    // 递归调用线性选择算法，查找B中的中位数m
    int m = linearSelect(medians, medians.size() / 2 + 1);

    // 使用快速排序的划分过程，将数组A分成两个部分：左边的元素小于等于m，右边的元素大于m
    vector<int> left, right;
    for (auto& num : nums) {
        if (num <= m) left.push_back(num);
        else right.push_back(num);
    }

    // 如果k小于等于左边部分的元素个数，则递归调用线性选择算法，在左边部分中查找第k小元素
    if (k <= left.size()) {
        return linearSelect(left, k);
    }
    // 如果k大于左边部分的元素个数加上右边部分的中位数个数，则递归调用线性选择算法，在右边部分中查找第k-leftCount-middleCount小元素
    else if (k > left.size() + count(medians.begin(), medians.end(), m)) {
        return linearSelect(right, k - left.size() - count(medians.begin(), medians.end(), m));
    }
    // 否则，返回m作为第k小元素
    else {
        return m;
    }
}

int main() {
    vector<int> nums = { 3, 1, 4, 2, 5, 7, 6, 8, 10, 9 };
    int k = 5;
    int result = linearSelect(nums, k);
    cout << "The " << k << "th smallest element is: " << result << endl;
    return 0;
}