hot100【acm版】【2026.7.13打卡-java版本】

是需要闭眼都会写的算法题

接雨水

package hot100;

public class lc42 {
     /*接雨水
    给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
    输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
    输出：6
    解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）
    */
    public int trap(int[] nums){
        //双指针
        int maxleft = nums[0];
        int maxright = nums[nums.length -1];

        int left = 1;
        int right = nums.length -2;

        int ans = 0;

        //这里是<=，不要忘记等于号！！！
        while(left <= right){
            if(maxleft < maxright){
                if(nums[left] > maxleft){
                    maxleft = nums[left];
                }else{
                    ans += maxleft - nums[left];
                }

                left++;
            }else{
                if(nums[right] > maxright){
                    maxright = nums[right];
                }else{
                    ans+= maxright - nums[right];
                }

                right--;
            }
        }

        return ans;
    }


    public static  void main(String[] args){
        lc42 solution = new lc42();
        int[] nums = new int[]{0,1,0,2,1,0,1,3,2,1,2,1};
        System.out.println("答案：" + solution.trap(nums));
    }



}

无重复子串

package hot100;

import java.util.*;

public class lc3 {
    /*无重复字符的最长子
    示例 1:
    输入: s = "abcabcbb"
    输出: 3
    解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。注意 "bca" 和 "cab" 也是正确答案*/
    public int  lengthOfLongestSubstring(String s){

        //滑动窗口+set
        Set<Character> set = new  HashSet<>();

        int left = 0;
        int right = 0;
        //这里初始化为0， 可能出现s为null的情况
        int max = 0;

        while(right < s.length()){
            char temp = s.charAt(right);

            if(!set.contains(temp)){
                set.add(temp);
                right++;
                max = Math.max(max,set.size());
            }else{
                char move = s.charAt(left);
                set.remove(move);
                left++;
            }
        }

        return max;

    }

    public static void main(String[] args) {
        lc3 solution = new lc3();
        String s =  "abcabcbb";
        System.out.println("答案：" + solution.lengthOfLongestSubstring(s));
    }

}

找到字符串中所有字母异位词

package hot100;
import java.util.*;
public class lc438 {
    /*
    *
    * 找到字符串中所有字母异位词
    给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。
    示例 1:
    输入: s = "cbaebabacd", p = "abc"
    输出: [0,6]
    解释:
    起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
    起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。*/

    //这个是第一时间自己想到的解法，时间和空间的效果都特别差
    public  List<Integer> findAnagrams(String s, String p){
        List<Integer> ans = new ArrayList<>();
        int left = 0;
        int right = p.length() ;
        //p->sort
        char[] temp  = p.toCharArray();
        Arrays.sort(temp);
        p = new String(temp);
        //这里是等于
        while(right <= s.length()){
            String sub_s = s.substring(left,right);
            char[] temp_sub_s = sub_s.toCharArray();
            Arrays.sort(temp_sub_s);
            sub_s = new String(temp_sub_s);
            if(p.equals(sub_s)){
                ans.add(left);
            }
            left++;
            right++;


        }

        return ans;

    }

    //左右指针--用整形数组装
    public List<Integer> findAnagrams1(String s, String p){
        //26个字母--int【】

        List<Integer> ans = new ArrayList<>();

        //特殊条件判断
        if(p.length() > s.length()){
            return ans;
        }
        int[] sLen= new int[26];
        int[] pLen = new int[26];

        for(int i = 0; i < p.length(); i++){
            sLen[s.charAt(i) - 'a'] ++;
            pLen[p.charAt(i) - 'a'] ++;
        }

        if(Arrays.equals(sLen, pLen)){
            ans.add(0);
        }

        for(int i = 1; i+p.length()-1 < s.length(); i++){
            sLen[s.charAt(i-1) - 'a']--;
            sLen[s.charAt(i+p.length()-1) - 'a']++;

            if(Arrays.equals(sLen,pLen)){
                ans.add(i);
            }

        }

        return ans;
    }




    public static void main(String[] args) {
        String s = "cbaebabacd";
        String p = "abc";
        lc438 solution = new lc438();
        System.out.println("答案：" + solution.findAnagrams(s,p));
        System.out.println("答案：" + solution.findAnagrams1(s,p));


    }


}

随机知识

1. HashMap在JDK1.7和1.8中有什么区别？

• 数据结构：1.7是数组+链表；1.8是数组+链表+红黑树，链表长度≥8且数组长度≥64时转红黑树。

• 插入方式：1.7头插法（扩容时可能死循环）；1.8尾插法，避免死循环。

• 扩容时机：1.7先扩容再插入；1.8先插入再扩容。

• Hash计算：1.7扰动4次；1.8扰动1次（高16位异或低16位），效率更高。

---

2. Synchronized锁升级过程是怎样的？

无锁 → 偏向锁 → 轻量级锁 → 重量级锁，不可逆。

• 偏向锁：只有一个线程访问时，在对象头记录线程ID，下次该线程进入无需加锁。

• 轻量级锁：有竞争时升级，通过CAS自旋尝试获取锁，适合锁持有时间短的场景。

• 重量级锁：自旋超过一定次数或竞争激烈时升级，线程挂起进入等待队列，由操作系统调度。

---

3. Spring Bean的生命周期是怎样的？

实例化 → 属性填充 → 初始化 → 使用 → 销毁。

• 实例化：通过反射创建Bean实例。

• 属性填充：注入依赖属性（@Autowired）。

• Aware回调：若实现BeanNameAware、BeanFactoryAware等接口，依次回调。

• 前置处理 ：BeanPostProcessor的postProcessBeforeInitialization。

• 初始化 ：@PostConstruct、InitializingBean的afterPropertiesSet、init-method依次执行。

• 后置处理 ：BeanPostProcessor的postProcessAfterInitialization（AOP代理在这里生成）。

• 使用：Bean就绪。

• 销毁 ：@PreDestroy、DisposableBean的destroy、destroy-method依次执行。

---

4. MySQL索引最左前缀原则是什么？

联合索引中，查询条件必须从索引的最左列开始，且不能跳过中间列，否则索引失效。

• 联合索引(a, b, c)：

  • WHERE a=1 走索引。

  • WHERE a=1 AND b=2 走索引。

  • WHERE b=2 不走索引（没从最左开始）。

  • WHERE a=1 AND c=3 只用a列索引，c不走（跳过了b）。

• 原因：联合索引按字段顺序构建B+树，第一列有序，第二列只在第一列相同时有序。

---

5. RocketMQ如何保证消息不丢失？

三个环节：

• 生产端：使用同步发送，发送失败重试2次；也可用事务消息保证本地事务和消息发送原子性。

• Broker端：配置同步刷盘（写入磁盘才返回成功）+ 主从同步复制（主从都写入才返回成功）。

• 消费端：消费完业务逻辑后再手动提交offset，不要自动提交；消费端做幂等防止重复消费。重试后仍失败进入死信队列，人工处理。

碎碎念：后续会更新每天学习的八股和算法 题，开始准备秋招的第64天。努力连续更新100天！以后每天就按，秋招项目【java +agent】，科研，必做项目，算法，八股，锻炼身体来总结。

总结：继续总结项目

1.hot100 【acm】 9/100 ，有点手感了

2.秋招项目，【java 项目】，

【agent 项目 】，2h

3.科研。确定方向就搞就可以了

4.实习；上班干杂活

6.背八股，无

7.锻炼身体，无

要点:少玩手机，多思考，多锻炼吧