分治—快速选择算法

分治—快速选择算法_第1张图片

文章目录

    • 215.数组中的第K个最大元素
      • 1. 题目
      • 2. 算法原理
      • 3. 代码实现
    • LCR 159. 库存管理 III
      • 1. 题目
      • 2. 算法原理
      • 代码实现

215.数组中的第K个最大元素

1. 题目

题目链接:215. 数组中的第K个最大元素 - 力扣(LeetCode)

给定整数数组 nums 和整数 k,请返回数组中第 **k** 个最大的元素。

请注意,你需要找的是数组排序后的第 k 个最大的元素,而不是第 k 个不同的元素。

你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

示例 1:

输入: [3,2,1,5,6,4], k = 2
输出: 5

示例 2:

输入: [3,2,3,1,2,4,5,5,6], k = 4
输出: 4

提示:

  • 1 <= k <= nums.length <= 105
  • -104 <= nums[i] <= 104

2. 算法原理

解法一:优先级队列(堆)

一般看到第k个什么什么元素,基本都是采用堆来解决,STL里面内置了堆,也就是priority_queue优先级队列,如果是竞赛或者是考试,可以直接用,如果是平时训练,可以自己手搓一个出来。

解法二:快速选择算法(快排)

快速选择算法是基于快排的

快排的核心思路:从数组里面随机选择一个基准元素,将数组分为三部分,即:>key==key

将数组分为三个区域之后,我们只需要看这个第k大的元素落在哪个区间即可,那如何确定第k大的元素在哪个区域,也是三种情况:

  • 设左边区间的元素个数为a个,中间区域的元素为b个,右边区间的元素个数为c

    1. c >= k,又区间都是大元素,我们看看有几个大元素,就能知道,第k个是不是在这个区间内,即[right,l]
    2. 当第一个条件不成立时,我们去中间区域找,也就是b+c >= k,在这个区域直接返回即可
    3. 上述两个条件都不成立的情况下,那我们只能去左侧区域[l,left]寻找,这时候要找的就是第k-b-c大的元素了

    分治—快速选择算法_第2张图片

3. 代码实现

堆:

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k)
    {
        int n = nums.size();
        buildMaxHeap(nums, n);
        for(int i=0;i<k-1;i++)
        {
            swap(nums[0],nums[n-1-i]);
            Adjustdown(nums,n-1-i,0);
        }
        return nums[0];
    }

    void buildMaxHeap(vector<int>& nums , int sz)
    {
        for(int i = (sz - 1 -1)/2; i>=0; i--)
        {
            Adjustdown(nums,sz,i);
        }
    }

    void Adjustdown(vector<int>& nums, int sz, int parent)
    {
        int child = parent*2+1;	//默认左孩子大
        while(child<sz)
        {
            if(child+1 < sz && nums[child] < nums[child+1])
            {
                child++;
            }
            if(nums[child] >nums[parent])
            {
                swap(nums[child],nums[parent]);
                parent = child;
                child = parent*2+1;
            }
            else    break;
        }
    }
};

快速选择:

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k)
    {
        srand(time(NULL));
        return quickSort(nums,0,nums.size()-1,k);
    }

    int quickSort(vector<int>& nums, int l, int r, int k)
    {
        if(l == r)  return nums[l];

        int key = getRandom(nums, l, r);
        //数组分为三部分
        int i = l, left = l-1, right = r+1;
        while(i<right)
        {
            if(nums[i] < key)   swap(nums[++left],nums[i++]);
            else if(nums[i] > key)  swap(nums[--right],nums[i]);
            else    i++;
        }

        //查看k在哪个区间
        int c = r - right + 1,
            b = right - left -1;
        if(c >= k)  return quickSort(nums,right,r,k);
        else if(b+c >= k)   return key;
        else    return quickSort(nums,l,left,k-b-c);
    }

    int getRandom(vector<int>& nums, int l, int r)
    {
        return nums[rand()%(r - l + 1) + l];
    }
};

运行结果:

分治—快速选择算法_第3张图片

LCR 159. 库存管理 III

1. 题目

题目链接:LCR 159. 库存管理 III

仓库管理员以数组 stock 形式记录商品库存表,其中 stock[i] 表示对应商品库存余量。请返回库存余量最少的 cnt 个商品余量,返回 顺序不限

示例 1:

输入:stock = [2,5,7,4], cnt = 1
输出:[2]

示例 2:

输入:stock = [0,2,3,6], cnt = 2
输出:[0,2][2,0]

提示:

  • 0 <= cnt <= stock.length <= 10000
  • 0 <= stock[i] <= 10000

2. 算法原理

这题就和上面这题差不多,这个是求最小的几个元素,顺序不限,解法很多

解法一:排序

直接排升序,然后返回前k个元素即可,时间复杂度O(N*logN)

解法二:堆

建一个大小为k的大根堆,将数据丢进这个堆,最后堆里面的元素就是我们要找的元素,时间复杂度O(N*logK)

详情可以看此篇文章数据结构——二叉树的3.3Top-K内容

解法三:快速选择算法

依旧是快排的核心思想:选取基准元素+数组分三块,时间复杂度为O(N)

还是这张图:

分治—快速选择算法_第4张图片

代码实现

class Solution {
public:
    vector<int> inventoryManagement(vector<int>& stock, int cnt)
    {
        srand(time(NULL));
        quickSort(stock, 0, stock.size()-1, cnt);
        return {stock.begin(),stock.begin()+cnt};
    }

    void quickSort(vector<int>& nums ,int l, int r, int k)
    {
        if(l >= r)  return;

        int key = getRandom(nums,l,r);
        int left = l-1,
            right = r+1,
            i = l;

        while(i<right)
        {
            if(nums[i] < key)   swap(nums[++left],nums[i++]);
            else if(nums[i] > key)  swap(nums[--right],nums[i]);
            else    i++;
        }

        //[l,left] [left+1,right-1] [right,r]
        int a = left - l + 1,
            b = right - left - 1;
        if(a > k)   quickSort(nums,l,left,k);
        else if(a+b >= k)    return;
        else    quickSort(nums,right,r,k-a-b);
    }

    int getRandom(vector<int>&  nums, int l, int r)
    {
        return nums[rand() % (r-l+1) + l];
    }
};

运行结果:

分治—快速选择算法_第5张图片

运行结果:
分治—快速选择算法_第6张图片

你可能感兴趣的:(原创,刷题,算法,数据结构,分治,排序算法)