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

34.在排序数组中查找元素的第一个和最后一个位置

示例 1：

复制代码

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

要点：//nums[mid] >= target，左边收

nums[mid] <= target，右边收

java 复制代码

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int left =  findLeft(nums,  target);
        int right = findRight(nums,  target);

        return new int[]{left, right};


    }


    public int findLeft(int[] nums, int target){
        int l = 0;
        int r = nums.length -1;
        int index = -1;
        while(l <= r){
            int mid = l + (r - l)/2;

            if(nums[mid] >= target){
                if(nums[mid] == target) index = mid;
                r = mid - 1;

            }else{
                l = mid + 1;
            }
        }

        return index;
    }


    public int findRight(int[] nums, int target){
        int l = 0;
        int r = nums.length -1 ;
        int index = -1;
        while(l <= r){
            int mid = l + (r - l)/2;

            if(nums[mid] <= target){
                if(nums[mid] == target) index = mid;
                l = mid+1;

            }else{
                r = mid -1;
            }
        }

        return index;
    }
}

140.训练计划2

给定一个头节点为 head 的链表用于记录一系列核心肌群训练项目编号，请查找并返回倒数第 cnt 个训练项目编号对应的节点。

复制代码

输入：head = [2,4,7,8], cnt = 1
输出：8

要点：另起一个node算长度，然后while（n > cnt) n--,倒着减法

java 复制代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode trainingPlan(ListNode head, int cnt) {

        //先算n 
        //n > cnt
        ListNode node = head;
        int n = 0;
        while(node != null){
            n++;
            node = node.next;
        }

        node = head;
        while(n > cnt){
            node = node.next;
            n--;
        }

        return node;

        
    }
}

129.求根节点到叶节点数字之和

给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。

每条从根节点到叶节点的路径都代表一个数字：

例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。

计算从根节点到叶节点生成的 所有数字之和 。

叶节点 是指没有子节点的节点。

要点：dfs！！！！老忘记dfs

java 复制代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */

 //咋还是学不会dfs呀！！！！，，递归然后出口，
class Solution {
    public int sumNumbers(TreeNode root) {
        //dfs
        return dfs(root,0);
        
    }

    public int dfs(TreeNode root, int prevSum){
       if(root == null){
            return 0;
        }

        int sum = prevSum*10 + root.val;

        if(root.left == null && root.right == null){
            return sum;
        }else{
            return dfs(root.left, sum) + dfs(root.right, sum);

        }


    }
}

155.最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

实现 MinStack 类:

MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。
void pop() 删除堆栈顶部的元素。
int top() 获取堆栈顶部的元素。
int getMin() 获取堆栈中的最小元素。

要点：/栈是 LIFO（后进先出），新元素永远只关心它下面所有元素中的最小值，而它下面的最小值已经由前一个栈顶（即上一个状态）的第二个值记录好了

stack<int []> 里面存数组

java 复制代码

class MinStack {

    //栈是 LIFO（后进先出），新元素永远只关心它下面所有元素中的最小值，而它下面的最小值已经由前一个栈顶（即上一个状态）的第二个值记录好了

    public Deque<int[]> stackMin = new ArrayDeque<>();

    public MinStack() {

        stackMin.push(new int[]{0, Integer.MAX_VALUE});
        
    }
    
    public void push(int val) {

        stackMin.push(new int[]{val,Math.min(val, getMin())});
        
    }
    
    public void pop() {
        stackMin.pop();
    }
    
    public int top() {
        return stackMin.peek()[0];
        
    }
    
    public int getMin() {
        return stackMin.peek()[1];
        
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(val);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

随机刷新知识

今天和deepseek模拟面试，项目是黑马点评的魔改，给我问的一愣一愣的。

第一轮提问

改造前是什么样子，改造后架构图大概如何？为什么选择加入 Redis 和 RabbitMQ，而不是数据库锁或别的方案？

第二轮提问

引入 Redis 和 RabbitMQ 后，完整的优惠券秒杀请求流程是怎样的？从点击"抢券"到看到结果，中间做了哪些关键操作？
Redis 具体存了什么，怎么解决超卖？
RabbitMQ 扮演什么角色？如果 Redis 扣减成功但 MQ 消息消费失败，怎么保证数据一致性？

第三轮提问

Lua 脚本具体逻辑是什么？做了哪几步判断？
有没有做限购判断（一人一单）？用户 ID 的限购信息存在哪个数据结构，如何与库存扣减保持原子性？
消费者写 MySQL 失败且重试耗尽时，Redis 库存少了但 MySQL 没订单，定时对账如何发现差异？
发现差异后补偿逻辑是回滚 Redis 库存还是继续重试创建订单？
若 Lua 成功后、发消息前服务宕机，如何保证已扣减但未发消息的操作不遗漏？

第四轮提问

对账信息表存在哪里？
信息表记录在什么时机写入？
信息表写入和 Lua 扣减是否在同一原子操作？如果扣库存成功但写信息表失败怎么办？
什么情况下正向重试，什么情况下逆向回滚？
如果用户因超时未看到订单又抢一次，限购被占，补偿怎么处理？
再次追问信息表写入时机与 Lua、发消息的时序，能否兜底宕机场景。

第五轮提问

信息表具体是 Redis 还是 MySQL？若是 Redis，用的什么数据结构，有没有过期？
写信息表失败但 Lua 已扣减，定时对账是否能发现？有无兜底手段？
判断补偿方向的"实际数据库"是指 Redis 还是 MySQL？
若需回滚，如何保证回滚的原子性？回滚也失败怎么办？
如果重新设计，如何可靠记录"已扣减未下单"状态？是改 Lua 脚本、用本地事务表还是其他？

第六轮提问

信息表 Hash 的 Key 如何设计？扫描效率如何？
在没有信息表记录的情况下，对账能否通过比对 Redis 总量与 MySQL 差异发现"幽灵扣减"？如何安全修复？
你提到的"本地事务表"方案具体如何实现？如何保证写表和发消息的原子性？
本地事务表方案相比 Redis Hash 方案的优势和挑战？
极端场景：Redis 预扣 100，MySQL 只成功 98，回滚后券重新放出，对用户公平性如何考虑？能否设计候补池？

第七轮提问

RabbitMQ 是否启用生产者确认？消息是否持久化？
消费者是手动 Ack 还是自动 Ack？
消费者抛异常时消息如何处理？是否配置死信队列？

我要缓一下，继续沉淀沉淀。

碎碎念：后续会更新每天学习的八股和算法题，暑假实习找不到了，开始准备秋招的第4天。努力连续更新100天！之前的日期感觉写错了，应该是记录今天的，今天主要是把找到的项目跑起来吧，然后vibecoding魔改一下，效率不是很高，准确说是实际进脑子的东西不多，继续加油！！嘿嘿，不管感觉终于找回点状态了，自信自信哇，一定可以找到想要的工作的。