每日算法一练:剑指offer——数组篇(3)

1.报数

实现一个十进制数字报数程序,请按照数字从小到大的顺序返回一个整数数列,该数列从数字 1 开始,到最大的正整数 cnt 位数字结束。

示例 1:

复制代码
输入:cnt = 2
输出:[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99]

1.1不考虑大数越界

题目要求打印 "从 1 至 cnt 的数字" ,最大的 cnt 位数(记为 end )和位数 cnt 的关系: 例如最大的 1 位数是 9 ,最大的 2 位数是 99 ,最大的 3 位数是 999 。则可推出公式:为10的cnt次方减去1。因此,只需定义区间 [1,10 cnt−1] 和步长 1 ,通过 for 循环生成结果列表 res 并返回即可。

java 复制代码
class Solution {
    public int[] countNumbers(int cnt) {
//查询数组最大值。
        int end = (int)Math.pow(10, cnt) - 1;
//创建对应长度数组。
        int[] res = new int[end];
//依次存储。
        for(int i = 0; i < end; i++)
            res[i] = i + 1;
        return res;
    }
}

1.2大数打印

实际上,本题的主要考点是大数越界情况下的打印。需要解决以下三个问题:

1. 表示大数的变量类型:

无论是 short / int / long ... 任意变量类型,数字的取值范围都是有限的。因此,大数的表示应用字符串 String 类型。

2. 生成数字的字符串集:

使用 int 类型时,每轮可通过 +1 生成下个数字,而此方法无法应用至 String 类型。并且, String 类型的数字的进位操作效率较低,例如 "9999" 至 "10000" 需要从个位到千位循环判断,进位 4 次。
观察可知,生成的列表实际上是 cnt 位 0 - 9 的 全排列 ,因此可避开进位操作,通过递归生成数字的 String 列表。

3. 递归生成全排列:

基于分治算法的思想,先固定高位,向低位递归,当个位已被固定时,添加数字的字符串。例如当 cnt=2 时(数字范围 1−99 ),固定十位为 0 - 9 ,按顺序依次开启递归,固定个位 0 - 9 ,终止递归并添加数字字符串。

复杂度分析:时间复杂度 O(10的cnt次方) : 递归的生成的排列的数量为 10的cnt次方。空间复杂度 O(10的cnt次方) 。结果列表 res 的长度为 10 cnt−1 ,各数字字符串的长度区间为 1,2,...,cnt ,因此占用 O(10 cnt) 大小的额外空间。

辅助函数 dfs(x, len) 的作用是:生成长度为len的数字,正在确定第 x 位。当 x=0 时表示左边第一位,不能为0,这样可以避免出现 0 开头的字符串。

代码实现:

java 复制代码
class Solution {
    List<Integer> res;   // 用于存储结果
    StringBuilder cur;   // 当前生成的数字
    char[] NUM = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};  // 允许使用的数字

    // 生成长度为 len 的数字,正在确定第 x 位(从左往右)
    void dfs(int x, int len) {
        if (x == len) {  // 递归终止条件:所有位数已经确定
            res.add(Integer.parseInt(cur.toString()));  // 将当前数字加入结果集,转换为整数
            return;
        }
        int start = (x == 0) ? 1 : 0;  // 如果是第一位数字,不能为 '0'
        for (int i = start; i < 10; i++) {
            cur.append(NUM[i]);  // 确定当前位的数字
            dfs(x + 1, len);     // 继续确定下一位
            cur.deleteCharAt(cur.length() - 1);  // 回溯,删除本位数字
        }
    }

    public int[] countNumbers(int cnt) {
        res = new ArrayList<>();  // 初始化结果集
        cur = new StringBuilder();  // 初始化当前数字生成器
        for (int i = 1; i <= cnt; i++) {  // 数字长度从 1 到 cnt
            dfs(0, i);  // 生成长度为 i 的所有数字
        }
        // 将结果转换为数组
        int[] resultArray = new int[res.size()];
        for (int i = 0; i < res.size(); i++) {
            resultArray[i] = res.get(i);
        }
        return resultArray;  // 返回结果数组
    }
}

1.3总结

本题主要考察大数越界,即用string来表示数组,且用递归生成全排列来生成数组。

​​​​​​2.训练计划I

2.1双线指针

教练使用整数数组 actions 记录一系列核心肌群训练项目编号。为增强训练趣味性,需要将所有奇数编号训练项目调整至偶数编号训练项目之前。请将调整后的训练项目编号以 数组 形式返回。

示例 1:

复制代码
输入:actions = [1,2,3,4,5]
输出:[1,3,5,2,4] 
解释:为正确答案之一

提示:

  • 0 <= actions.length <= 50000
  • 0 <= actions[i] <= 10000

考虑定义双指针 i , j 分列数组左右两端,循环执行:

指针 i 从左向右寻找偶数;
指针 j 从右向左寻找奇数;
将 偶数 actions[i] 和 奇数 actions[j] 交换。
可始终保证: 指针 i 左边都是奇数,指针 j 右边都是偶数 。

时间复杂度 O(N) : N 为数组 actions 长度,双指针 i, j 共同遍历整个数组。空间复杂度 O(1) : 双指针 i, j 使用常数大小的额外空间。

代码实现:

java 复制代码
class Solution {
    public int[] trainingPlan(int[] actions) {
//定义两个指针,分别指向首尾两端。
        int i = 0, j = actions.length - 1, tmp;
//确保指针顺序
        while(i < j) {
//确保指针指向需调换元素上。
            while(i < j && (actions[i] & 1) == 1) i++;
            while(i < j && (actions[j] & 1) == 0) j--;
//若指到同一位置,互换无影响。
            tmp = actions[i];
            actions[i] = actions[j];
            actions[j] = tmp;
        }
        return actions;
    }
}

2.2 总结

题主要考察双向指针的灵活运用,其中要注意判断条件的选取。

3.库存管理II

仓库管理员以数组 stock 形式记录商品库存表。stock[i] 表示商品 id,可能存在重复。请返回库存表中数量大于 stock.length / 2 的商品 id

示例 1:

复制代码
输入:stock = [6, 1, 3, 1, 1, 1]
输出:1

限制:

  • 1 <= stock.length <= 50000
  • 给定数组为非空数组,且存在结果数字

3.1哈希表统计法

遍历数组 stock ,用 HashMap 统计各数字的数量,即可找出 众数 。此方法时间和空间复杂度均为 O(N) 。

代码实现:

java 复制代码
class Solution {
    public int inventoryManagement(int[] stock) {
        // 创建一个 HashMap 来存储元素和它们的出现次数
        Map<Integer, Integer> map = new HashMap<>();
        
        // 计算数组长度的一半,用于判断某元素是否出现超过一半
        int n = stock.length / 2;
        
        // 遍历数组中的每一个元素
        for (int num : stock) {
            // 统计每个元素的出现次数,如果元素不在 map 中,则默认次数为 0
            map.put(num, map.getOrDefault(num, 0) + 1);
            
            // 如果某个元素的次数超过数组长度的一半,返回该元素
            if (map.get(num) > n)
                return num;
        }
        
        // 如果没有找到符合条件的元素,返回 0
        return 0;
    }
}

3.2数组排序法

将数组 stock 排序,数组中点的元素 一定为众数。时间复杂度: O(Nlog⁡N),因为排序的时间复杂度是 O(Nlog⁡N)。空间复杂度: O(1)(对于原地排序),或者 O(N)(取决于排序算法实现)。

java 复制代码
class Solution {
    public int inventoryManagement(int[] stock) {
        // 首先对数组进行排序
        Arrays.sort(stock);
        
        // 返回数组中间的元素,众数一定在中间位置
        return stock[stock.length / 2];
    }
}

3.3摩尔投票法

核心理念为 票数正负抵消 。此方法时间和空间复杂度分别为 O(N) 和 O(1) ,为本题的最佳解法。

摩尔投票法:
设输入数组 stock 的众数为 x ,数组长度为 n 。

推论一: 若记 众数 的票数为 +1 ,非众数 的票数为 −1 ,则一定有所有数字的 票数和 >0 。

推论二: 若数组的前 a 个数字的 票数和 =0 ,则 数组剩余 (n−a) 个数字的 票数和一定仍 >0 ,即后 (n−a) 个数字的 众数仍为 x 。

摩尔投票法(Boyer-Moore Voting Algorithm)是一种用于寻找数组中众数的高效算法。众数是指在数组中出现次数超过数组长度一半的元素。该算法的主要特点是时间复杂度为 O(N)且空间复杂度为 O(1),非常适合处理这个问题。

算法原理

摩尔投票法的核心思想是利用计数来确定候选众数。具体步骤如下:

  1. 初始化

    • 定义一个变量 candidate 来存储当前候选的众数,和一个 count 来记录候选众数的计数,初始值为 0。
  2. 遍历数组

    • 对于数组中的每个元素:
      • 如果 count 为 0,更新 candidate 为当前元素,并将 count 设为 1。
      • 如果当前元素等于 candidate,则 count 加 1。
      • 如果当前元素不等于 candidate,则 count 减 1。
  3. 返回结果

    • 因为题目保证存在众数,所以在结束遍历后,candidate 就是众数。

代码实现:

java 复制代码
class Solution {
    public int inventoryManagement(int[] stock) {
        // 变量 x 用于存储当前认为的候选众数,votes 用于统计支持度,count 用于验证候选众数的出现次数
        int x = 0, votes = 0, count = 0;

        // 第一遍历,找出候选众数
        for (int num : stock) {
            // 如果当前支持度为 0,则更新候选众数为当前元素 num
            if (votes == 0)
                x = num;
            // 更新支持度:如果 num 与候选众数相同,支持度加 1;否则减 1
            votes += (num == x) ? 1 : -1;
        }

        // 第二遍历,验证候选众数 x 是否为真正的众数
        for (int num : stock)
            // 统计候选众数 x 的出现次数
            if (x == num)
                count++;

        // 如果候选众数的出现次数大于数组长度的一半,则返回众数 x;否则返回 -1(表示无众数)
        return count > (stock.length / 2) ? x : -1;
    }
}

4.总结

本题主要考察寻找中位数中的摩尔投票法,该方法可提高算法性能。

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)。

算法原理

  1. 选择基准:从数组中选择一个元素作为基准(pivot),可以选择第一个元素、最后一个元素或随机选择。

  2. 分区操作:重新排列数组,将比基准小的元素放到基准的左边,将比基准大的元素放到右边。经过分区后,基准元素在其最终位置上。

  3. 递归排序:对基准左边和右边的子数组递归进行快速排序。

  4. 终止条件:当子数组的大小为 0 或 1 时,表示该子数组已经排好序,递归结束。

代码实现:

java 复制代码
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)来高效地实现这个目标。以下是实现的详细步骤和代码。

算法原理

  1. 选择基准:在数组中选择一个基准元素(可以选择最后一个元素)。

  2. 哨兵划分:对数组进行哨兵划分,将小于等于基准的元素放在基准的左侧,将大于基准的元素放在右侧。

  3. 判断基准位置

    • 每次划分后检查基准元素的索引。
    • 如果基准元素的索引正好等于 cnt,则返回数组中前 cnt 个元素。
    • 如果基准元素的索引小于 cnt,则说明最小的 cnt 个数在基准的右侧,需要对右侧部分继续进行划分。
    • 如果基准元素的索引大于 cnt,则说明最小的 cnt 个数在基准的左侧,需要对左侧部分继续进行划分。

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

代码实现:

java 复制代码
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总结

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

相关推荐
Wx120不知道取啥名16 分钟前
C语言之长整型有符号数与短整型有符号数转换
c语言·开发语言·单片机·mcu·算法·1024程序员节
开心工作室_kaic42 分钟前
ssm010基于ssm的新能源汽车在线租赁管理系统(论文+源码)_kaic
java·前端·spring boot·后端·汽车
代码吐槽菌43 分钟前
基于SSM的汽车客运站管理系统【附源码】
java·开发语言·数据库·spring boot·后端·汽车
Iareges1 小时前
美团2025校招 广告算法工程师 面经
算法·面试·求职招聘·笔试·秋招
zdkdchao1 小时前
jdk,openjdk,oraclejdk
java·开发语言
精致先生2 小时前
问题记录01
java·数据库·mybatis
堇舟2 小时前
斯皮尔曼相关(Spearman correlation)系数
人工智能·算法·机器学习
小魏冬琅2 小时前
探索面向对象的高级特性与设计模式(2/5)
java·开发语言
TT哇2 小时前
【Java】数组的定义与使用
java·开发语言·笔记
look_outs3 小时前
JavaSE笔记2】面向对象
java·开发语言