每日算法一练：剑指offer——数组篇（3）

4.库存管理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

4.1快速排序法

本题使用排序算法解决最直观，对数组 stock 执行排序，再返回前 cnt 个元素即可。

快速排序（Quick Sort）是一种高效的排序算法，采用分治法（Divide and Conquer）策略，通过一个称为“基准”（pivot）的元素将数组分为两个子数组，然后递归地对这两个子数组进行排序。快速排序的平均时间复杂度为 O(Nlog⁡N)，但最坏情况下为 O(N^2)。空间复杂度 O(N) ：快速排序的递归深度最好（平均）为 O(logN) ，最差情况（即输入数组完全倒序）为 O(N)。

算法原理

选择基准：从数组中选择一个元素作为基准（pivot），可以选择第一个元素、最后一个元素或随机选择。
分区操作：重新排列数组，将比基准小的元素放到基准的左边，将比基准大的元素放到右边。经过分区后，基准元素在其最终位置上。
递归排序：对基准左边和右边的子数组递归进行快速排序。
终止条件：当子数组的大小为 0 或 1 时，表示该子数组已经排好序，递归结束。

代码实现：

class Solution {
    public int[] inventoryManagement(int[] stock, int cnt) {
        quickSort(stock, 0, stock.length - 1); // 调用快速排序
        return Arrays.copyOf(stock, cnt); // 返回前 cnt 个库存项
    }
    
    private void quickSort(int[] stock, int l, int r) {
        // 子数组长度为 1 时终止递归
        if (l >= r) return;

        // 哨兵划分操作（以 stock[l] 作为基准数）
        int i = l, j = r;
        while (i < j) {
            while (i < j && stock[j] >= stock[l]) j--; // 从右向左找到第一个小于基准数的元素
            while (i < j && stock[i] <= stock[l]) i++; // 从左向右找到第一个大于基准数的元素
            swap(stock, i, j); // 交换这两个元素
        }
        swap(stock, i, l); // 把基准数放到它最终的位置

        // 递归左（右）子数组执行哨兵划分
        quickSort(stock, l, i - 1); // 对左子数组排序
        quickSort(stock, i + 1, r); // 对右子数组排序
    }
    
    private void swap(int[] stock, int i, int j) {
        int tmp = stock[i]; // 交换元素
        stock[i] = stock[j];
        stock[j] = tmp;
    }
}

4.2快速选择法

根据给出的题目要求，我们需要返回库存余量最少的 cnt 个商品余量，且返回顺序不限。可以使用快速选择算法（Quick Select）来高效地实现这个目标。以下是实现的详细步骤和代码。

算法原理

选择基准：在数组中选择一个基准元素（可以选择最后一个元素）。
哨兵划分：对数组进行哨兵划分，将小于等于基准的元素放在基准的左侧，将大于基准的元素放在右侧。
判断基准位置：
- 每次划分后检查基准元素的索引。
- 如果基准元素的索引正好等于 cnt，则返回数组中前 cnt 个元素。
- 如果基准元素的索引小于 cnt，则说明最小的 cnt 个数在基准的右侧，需要对右侧部分继续进行划分。
- 如果基准元素的索引大于 cnt，则说明最小的 cnt 个数在基准的左侧，需要对左侧部分继续进行划分。

本方法优化时间复杂度的本质是通过判断舍去了不必要的递归（哨兵划分）。时间复杂度 O(N) ：其中 N 为数组元素数量；对于长度为 N 的数组执行哨兵划分操作的时间复杂度为 O(N) ；空间复杂度 O(logN) ：划分函数的平均递归深度为 O(logN) 。

代码实现：

class Solution {
    // 主方法：返回库存余量最少的 cnt 个商品余量
    public int[] inventoryManagement(int[] stock, int cnt) {
        // 如果 cnt 大于等于数组长度，直接返回整个数组
        if (cnt >= stock.length) return stock;
        // 调用快速选择方法，寻找最小的 cnt 个商品余量
        return quickSort(stock, cnt, 0, stock.length - 1);
    }

    // 辅助方法：快速选择算法，用于找到最小的 cnt 个元素
    private int[] quickSort(int[] stock, int cnt, int l, int r) {
        // 初始化左右指针
        int i = l, j = r;
        
        // 哨兵划分过程
        while (i < j) {
            // 从右向左，找到第一个小于基准元素的元素
            while (i < j && stock[j] >= stock[l]) j--;
            // 从左向右，找到第一个大于基准元素的元素
            while (i < j && stock[i] <= stock[l]) i++;
            // 交换这两个元素
            swap(stock, i, j);
        }
        
        // 交换基准元素到正确的位置
        swap(stock, i, l);
        
        // 判断基准元素的位置
        if (i > cnt) {
            // 如果基准元素位置大于 cnt，继续在左侧查找
            return quickSort(stock, cnt, l, i - 1);
        }
        if (i < cnt) {
            // 如果基准元素位置小于 cnt，继续在右侧查找
            return quickSort(stock, cnt, i + 1, r);
        }
        // 如果基准位置等于 cnt，返回前 cnt 个最小的元素
        return Arrays.copyOf(stock, cnt);
    }

    // 交换数组中两个元素的辅助方法
    private void swap(int[] stock, int i, int j) {
        int tmp = stock[i]; // 保存第一个元素的值
        stock[i] = stock[j]; // 将第二个元素赋值给第一个元素
        stock[j] = tmp; // 将保存的第一个元素值赋给第二个元素
    }
}

4.3总结

本题考查快速排序和快速选择两种高效的查找和选择算法。