topcode【随机算法题】【2026.5.20打卡-java版本】

旋转图像

要点：【i】【j] = [n-1-j-】【i]

class Solution { public void rotate(int[][] matrix) { //[i][j] = [n-1-j][i] int n = matrix.length; for(int i = 0; i < n/2; i++){ for(int j = i; j < n-1-i; j++){ int temp = matrix[i][j]; matrix[i][j] = matrix[n-1-j][i]; matrix[n-1-j][i] =matrix[n-1-i][n-1-j]; matrix[n-1-i][n-1-j] = matrix[j][n-1-i]; matrix[j][n-1-i] = temp; } } } }

最小覆盖长度

要点： 双指针，两个map

class Solution { public String minWindow(String s, String t) { if (s == null || t == null || s.length() == 0 || t.length() == 0) { return ""; } // 记录需要的字符及其数量 Map<Character, Integer> need = new HashMap<>(); for (char c : t.toCharArray()) { need.put(c, need.getOrDefault(c, 0) + 1); } // 记录窗口中的字符及其数量 Map<Character, Integer> window = new HashMap<>(); int left = 0, right = 0; int valid = 0; // 窗口中满足need条件的字符种类数 // 记录最小覆盖子串的起始索引和长度 int start = 0; int minLen = Integer.MAX_VALUE; while (right < s.length()) { // 扩大窗口 char c = s.charAt(right); right++; // 更新窗口数据 if (need.containsKey(c)) { window.put(c, window.getOrDefault(c, 0) + 1); // 如果窗口中该字符的数量达到need中需要的数量，则valid+1 if (window.get(c).equals(need.get(c))) { valid++; } } // 当窗口已包含t的所有字符时，尝试缩小窗口 while (valid == need.size()) { // 更新最小覆盖子串 if (right - left < minLen) { start = left; minLen = right - left; } // 缩小窗口 char d = s.charAt(left); left++; // 更新窗口数据 if (need.containsKey(d)) { // 如果窗口中该字符的数量等于need中需要的数量，则valid-1 if (window.get(d).equals(need.get(d))) { valid--; } window.put(d, window.get(d) - 1); } } } return minLen == Integer.MAX_VALUE ? "" : s.substring(start, start + minLen); } }

轮转数组

要点：全反转， 然后前面反转，然后后面反转

class Solution { public void rotate(int[] nums, int k) { int n = nums.length; k = k %n; reverse(nums, 0, n-1); reverse(nums, 0, k-1); reverse(nums, k, n-1); } public void reverse(int[] nums, int i, int j){ while(i < j){ int temp = nums[i]; nums[i] = nums[j]; nums[j] = temp; i++; j--; } } }

除了自身以外数组的乘积

要点：左右的数组维护

class Solution { public int[] productExceptSelf(int[] nums) { int[] Lsums = new int[nums.length]; int[] Rsums = new int[nums.length]; Lsums[0] = nums[0]; for(int i = 1; i<nums.length; i++){ Lsums[i] = Lsums[i-1]*nums[i]; } Rsums[nums.length-1] = nums[nums.length -1]; for(int j = nums.length - 2; j>=0; j--){ Rsums[j] = Rsums[j+1]*nums[j]; } int[] ans = new int[nums.length]; for(int i = 0; i < nums.length; i++){ if(i == 0){ ans[i] = Rsums[1]; }else if(i == nums.length - 1){ ans[i] = Lsums[i-1]; }else{ ans[i] = Rsums[i+1] * Lsums[i-1]; } } return ans; } }

随机知识

设计模式（高频，必问 2-3 个）

核心题：你用过哪些设计模式？项目中怎么用的？

面试官为什么这么问：考察代码设计能力，看你写代码是不是只求“能跑就行”。实习生能说出 3 种以上并讲清应用场景，就是优秀。

需要掌握的模式及回答方向：

面试官爱追问：

• 单例双重检查锁为什么加 volatile？→ 你已经知道（禁止指令重排）
• Spring 用了哪些设计模式？→ 至少能说代理、模板方法、单例、工厂

准备建议：不用单独背，上面每个点都能和 Spring 框架、你的项目关联讲出来。

候选人：
好的。设计模式本质上是解决特定问题的成熟方案，我在项目里用过六种，每种都有明确的应用场景。

第一种，单例模式——全局唯一实例。

单例的核心是保证一个类在整个应用中只有一个实例，节省资源并保证状态一致。Spring 容器中的 Bean 默认就是单例的，这是最典型的应用。我项目里用枚举单例管理全局配置，枚举天然防反射和反序列化破坏，是最安全的方式。实现上优先用枚举，非枚举场景用静态内部类持有实例保证延迟加载和线程安全。

重点补充：如果面试官追问双重检查锁定（DCL），我需要说明 DCL 中volatile的作用。instance = new Singleton()底层拆成分配内存、初始化对象、将引用指向内存三步，JVM 可能重排让引用先指向未初始化好的内存。另一个线程在第一次检查时发现引用不为 null，直接返回未初始化完成的对象，导致程序出错。volatile通过内存屏障禁止这种重排序，保证对象完全初始化后才被外界看到。

第二种，工厂模式——解耦对象创建。

当一个对象的创建逻辑比较复杂，或者需要根据条件创建不同实现类时，我用工厂模式。它分简单工厂、工厂方法和抽象工厂三个层次。简单工厂用一个工厂类根据参数返回不同的产品实例；工厂方法是定义一个创建对象的接口，让子类决定实例化哪个类；抽象工厂用于创建一系列相关的产品族。

在面试 Agent 项目里，大模型调用层正是用得上的场景。不同模型（GPT-4、Claude、文心一言）接口不同、认证方式不同。定义一个统一的模型调用接口，然后为每个模型写一个具体实现类，再用工厂根据配置动态创建对应的调用器。新增模型只需添加实现类和工厂分支，业务代码零改动。

第三种，策略模式——消除 if-else。

策略模式定义一系列算法，把它们封装起来，让它们可以互相替换，与工厂模式的区别在于前者关注“创建”，后者关注“行为互换”。当代码里出现大量 if-else 或 switch 判断行为逻辑时，策略模式就很有用。

项目里面试题评分模块用了策略模式。不同题目类型（算法题、系统设计题、行为面试题）的评分规则完全不同。定义统一的评分策略接口，每种题型实现对应的策略类，再用一个工厂或 Map 根据题目类型获取对应策略执行。新增题目类型只需增加一个策略实现类，无需修改原有评分逻辑，完全符合开闭原则。

第四种，代理模式——无侵入增强。

代理模式给一个对象提供一个代理对象，由代理控制对原对象的访问，核心作用是在不修改原始类的情况下，增加额外的功能。Spring AOP 就是最典型的应用。

项目里的事务管理、日志记录都靠 AOP 实现。比如 @Transactional 注解，Spring 为加了该注解的 Bean 生成代理对象，在方法调用前后自动开启和提交/回滚事务。业务代码完全无感知，干净纯粹。日志切面记录请求耗时和异常信息，同样不侵入业务方法。

第五种，模板方法模式——定义算法骨架。

模板方法定义一个算法的骨架，把一些步骤延迟到子类实现。Spring 里的 JdbcTemplate、RedisTemplate 就是模板方法模式的典型应用。JdbcTemplate.execute()定义了“获取连接 → 执行 SQL → 处理结果集 → 关闭连接”的固定流程，SQL 语句和结果映射由传入的回调或匿名子类实现，整体流程由模板严格控制。

第六种，观察者模式——一对多通知。

观察者模式定义对象间的一对多依赖关系，当主题对象状态改变时，所有依赖它的观察者都会收到通知并自动更新。

Spring 的事件机制就是观察者模式的标准实现。在一个订单服务里，订单支付成功后发布PaymentSuccessEvent，积分服务监听该事件自动增加积分，短信服务监听该事件发送支付成功通知。订单服务只负责发布事件，不关心谁在监听，完全解耦。新增消费者只需添加监听器，无需修改订单服务代码。还可以用@Async把事件处理变成异步，不阻塞主流程。

面试官追问：Spring 用了哪些设计模式？

Spring 框架大量使用设计模式，常用的有代理模式（AOP）、单例模式（默认 Bean 作用域）、工厂模式（BeanFactory）、模板方法模式（JdbcTemplate、RestTemplate）、观察者模式（Spring Event、ApplicationListener）、责任链模式（拦截器链、Filter Chain）。这些模式共同支撑起 Spring 的 IoC、AOP 等核心能力。

总结：设计模式不是炫技的工具，而是解决实际问题的套路。我用单例管理全局资源、工厂解耦对象创建、策略消除冗长 if-else、代理无侵入增强功能、模板方法统一复杂流程、观察者解耦事件通知。核心原则是对扩展开放，对修改关闭，保证代码的可维护性和可扩展性。设计模式的价值在于选择，而不是堆砌——如果一个场景不需要用模式，强行套用反而让代码变得更复杂。

碎碎念：后续会更新每天学习的八股和算法 题，暑假实习找不到了，开始准备秋招的第10天。努力连续更新100天！把项目收尾？接个agent看看？然后要开始搞科研，要不然毕不了业了。时间不够用了哇。好，睡前再看一下八股吧，该背背！！！