力扣Hot100（Java版本）

已于 2025-05-15 15:42:54 修改
阅读量444 收藏 7
点赞数 3
文章标签： leetcode java 算法
于 2025-05-13 22:08:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_69032308/article/details/147935041
版权

写在前文：由于LeetCode100的答案多种多样，本文针对每一题只写一种解法（尽可能简单易懂）。针对不容易理解的，采用图片形式。

1. 哈希

1.1 两数之和

题目描述：

  • 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

  • 你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

  • 你可以按任意顺序返回答案。

力扣链接：

https://leetcode.cn/problems/two-sum/description/【简单】

解题思路：

  1. 实例化一个HashMap来保存<值, 索引>

  2. 遍历HashMap，找到就返回索引下标，找不到就添加元素

核心代码：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        // map保存<值,索引>
        Map<Integer,Integer> map = new HashMap<>();
        for(int i = 0; i < nums.length; ++i){
            if(map.containsKey(target - nums[i])){
                return new int[]{map.get(target - nums[i]),i};
            }
            map.put(nums[i],i); // 返回[索引1，索引2]
        }
        return new int[0]; // 返回[]
    }
}

1.2 字母异位词分组

题目描述：

  • 给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

  • 字母异位词 是由重新排列源单词的所有字母得到的一个新单词。

力扣链接：

https://leetcode.cn/problems/group-anagrams/description【中等】

解题思路：

  1. Map保存<排序后的字符串, List<String>>
  2. 遍历strs, 依次添加到Map

核心代码：

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        // 1. Map保存<排序后的str, List<String>>
        Map<String, List<String>> map = new HashMap<>();
        // 2. 遍历strs, 依次添加到Map
        for (String str : strs){
            char[] charStr = str.toCharArray();
            Arrays.sort(charStr);
            String orderStr = new String(charStr);
            if (map.containsKey(orderStr)){
                map.get(orderStr).add(str);
            }else{
                List<String> temp = new ArrayList<>();
                temp.add(str);
                map.put(orderStr,temp);
            }
        }
        return new ArrayList<List<String>>(map.values());
    }
}

1.3 最长连续序列

题目描述：

  • 给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。

  • 请你设计并实现时间复杂度为 O(n) 的算法解决此问题。

力扣链接：

https://leetcode.cn/problems/longest-consecutive-sequence/description【中等】

解决思路：

  1. 将nums数组的所有元素放入HashSet，去除重复元素
  2. 从序列的最小值开始找，更新最大值

核心代码：

class Solution {
    public int longestConsecutive(int[] nums) {
      	// 1. 将nums数组的所有元素放入HashSet, 去除重复元素
        HashSet<Integer> hs = new HashSet<>();
        for (int i : nums){
            hs.add(i);
        }
        int ans = 0;
        for (int i : hs){
            // 2. 只从序列的最小值开始找
            if (!hs.contains(i - 1)){
                int curAns = 1;
                while(hs.contains(i+1)){
                    i++;
                    curAns++;
                }
                ans = Math.max(ans,curAns);
            }
        }
        return ans; 
    }
}

2. 双指针

2.1 移动零

题目描述：

  • 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

  • 请注意 ，必须在不复制数组的情况下原地对数组进行操作。

力扣链接：

https://leetcode.cn/problems/move-zeroes/【简单】

解题思路：

  • 核心思想：当 left指针指向第一个0，right指针指向第一个非0时，交换元素

  • 解题流程：

    1. 初始化left指针位0，right指针为0

    2. 遍历right指针

      • 如果right指针的元素为0，right++

      • 如果right指针的元素不为0，交换元素，left++，right++

核心代码：

class Solution {
    public void moveZeroes(int[] nums) {
        // 1. 初始化left和right指针为0
        int left = 0;
        int right = 0;
        // 2. 遍历right指针。right指针的元素为0 ？ right++ : {swap(l,r), l++, r++}
        while(right < nums.length){
            if (nums[right] == 0){
                right++;
            }else{
                swap(nums,left,right);
                left++;
                right++;
            }
        }
    }

    public void swap(int[] nums, int i, int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp; 
    }
}

2.2 盛最多水的容器

题目描述：

  • 给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

  • 找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

  • 返回容器可以储存的最大水量。

  • **说明：**你不能倾斜容器。

力扣链接：

https://leetcode.cn/problems/container-with-most-water/description/【中等】

解题思路：

  • 初始化左，右指针，最大面积。
  • 计算当前面积, 更新最大面积，短指针向中间移动

核心代码：

class Solution {
    public int maxArea(int[] height) {
        // 1. 初始化左右指针, 最大面积
        int left = 0;
        int right = height.length - 1;
        int maxArea = 0;
        // 2. 计算当前面积, 更新最大面积，短指针向中间移动
        while(left < right){
            int curArea = (right - left) * Math.min(height[left],height[right]);
            maxArea = Math.max(maxArea,curArea);
            if (height[left] < height[right]){
                left++;
            }else{
                right--;
            }
        }
        return maxArea; 
    }
}

2.3 三数之和

题目描述：

  • 给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

  • **注意：**答案中不可以包含重复的三元组。

力扣链接：

https://leetcode.cn/problems/3sum/description【中等】

解题思路：

  • 三数之和变成两数之和
  • 避免重复解
  • 直接看代码+注释，理解背下来吧

核心代码：

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>(); // 创建一个列表用于存储最终的答案
        
        Arrays.sort(nums); // 首先对数组进行排序，这样可以方便地使用双指针方法查找组合

        for (int i = 0; i < nums.length - 2; ++i){ // 循环遍历数组中的每一个元素，但最后两个元素不需要作为起始点考虑
            if (i > 0 && nums[i] == nums[i-1]) continue; // 如果当前元素和前一个元素相同，则跳过以避免重复解
            
            // 设置目标值为 -nums[i]，因为我们需要找到三个数之和为0的组合，即 nums[i] + nums[l] + nums[r] = 0
            int target = - nums[i];
            int l = i + 1; // 左指针初始化为当前元素的下一个位置
            int r = nums.length - 1; // 右指针初始化为数组最后一个元素的位置
            
            while(l < r){ // 当左指针小于右指针时继续循环
                int sum = nums[l] + nums[r]; // 计算左右指针所指元素的和
                
                if (target == sum){ // 如果找到的和正好等于目标值
                    ans.add(Arrays.asList(nums[i], nums[l], nums[r])); // 将找到的三元组添加到答案中
                    
                    // 跳过所有相同的左指针指向的值，避免重复解
                    while(l < r && nums[l] == nums[l + 1]) l++;
                    // 跳过所有相同的右指针指向的值，避免重复解
                    while(l < r && nums[r] == nums[r - 1]) r--;
                    
                    l++; // 移动左指针
                    r--; // 移动右指针
                } else if(target > sum){ // 如果需要更大的和，移动左指针
                    l++;
                }else{ // 如果需要更小的和，移动右指针
                    r--;
                }
            }
        }
        return ans; // 返回所有找到的不重复的三元组
    }
}

2.4 接雨水

题目描述：

  • 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

力扣链接：

https://leetcode.cn/problems/trapping-rain-water/description【困难】

解题思路

  • 对于下标 i，下雨后水能到达的最大高度等于下标 i 两边的最大高度的最小值，下标 i 处能接的雨水量等于下标 i 处的水能到达的最大高度减去 height[i]。

  • leftMax[i] 表示下标 i 及其左边的位置中，height 的最大高度，rightMax[i] 表示下标 i 及其右边的位置中，height 的最大高度。

  • 动态规划

  • 计算每个下标i可以接的雨水量：sum[i] = min(i左侧最大高度,i右侧最大高度) - height[i]

image-20250407172249447
注意：本题采用的是动态规划解法。。。理解不了就背这个图。

核心代码

class Solution {
    public int trap(int[] height) {
        int n = height.length;
        if (n == 0) return 0;

        int[] leftMax = new int[n];
        int[] rightMax = new int[n];

        // 填充 leftMax
        int curLeftMax = 0;
        for (int i = 0; i < n; ++i) {
            leftMax[i] = Math.max(height[i], curLeftMax);
            curLeftMax = leftMax[i];  // 更新当前最大值
        }

        // 填充 rightMax
        int curRightMax = 0;
        for (int i = n - 1; i >= 0; --i) {
            rightMax[i] = Math.max(height[i], curRightMax);
            curRightMax = rightMax[i];  // 更新当前最大值
        }

        // 计算能接多少水
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            ans += Math.min(leftMax[i], rightMax[i]) - height[i];
        }

        return ans;
    }
}

3. 滑动窗口

3.1 无重复字符的最长子串

题目描述：

  • 给定一个字符串 s ，请你找出其中不含有重复字符的 最长 子串 的长度。

力扣链接：

https://leetcode.cn/problems/longest-substring-without-repeating-characters/【中等】

解题思路：

  • 双指针滑动
  • Set保存不含重复字符子串

核心代码：

class Solution {
    public int lengthOfLongestSubstring(String s) {
        // 使用 HashSet 来记录当前窗口中的字符（便于快速判断是否有重复字符）
        Set<Character> set = new HashSet<>();
        
        // ans：记录最长无重复子串的长度
        // left：滑动窗口左指针
        // right：滑动窗口右指针
        int ans = 0, left = 0, right = 0;

        // 右指针从左向右移动，扩展窗口
        for (; right < s.length(); right++) {
            char ch = s.charAt(right);  // 当前要加入窗口的字符

            // 如果当前字符已经在集合中存在，说明窗口中有重复字符
            // 需要不断将左指针右移，直到重复字符被移除
            while (set.contains(ch)) {
                set.remove(s.charAt(left));  // 移除最左边的字符
                left++;                      // 左指针右移
            }

            // 此时窗口中已经没有重复字符，把当前字符加入集合
            set.add(ch);

            // 计算当前窗口长度，并更新最大值
            ans = Math.max(ans, right - left + 1);
        }

        return ans;  // 返回最长无重复子串的长度
    }
}

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

题目描述：

  • 给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。

踩坑点：题目描述不清晰，两个单词包含相同的字符且每个字符出现的次数也相同。

力扣链接：

https://leetcode.cn/problems/find-all-anagrams-in-a-string/description/【中等】

解题思路：

  • 创建两个长度为26的数组分别表示目标字符串p和滑动窗口的字符频率
  • Arrays.equal比较两个数组是否相同（索引对应的值全部一样）
  • 本质：空间换时间

核心代码：

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> ans = new ArrayList<>();
        int len_s = s.length();
        int len_p = p.length();

        // 特殊情况处理
        if (len_s < len_p) return ans;

        // 创建两个长度为26的数组分别表示目标字符串p和滑动窗口的字符频率
        int[] pCount = new int[26];
        int[] windowCount = new int[26];

        // 初始化目标p的字符频率
        for (char ch : p.toCharArray()) {
            pCount[ch - 'a']++;
        }

        // 滑动窗口初始化：前 len_p 个字符
        for (int i = 0; i < len_p; i++) {
            char ch = s.charAt(i);
            windowCount[ch - 'a']++;
        }

        // 如果初始窗口匹配，添加起始索引0
        if (Arrays.equals(pCount, windowCount)) {
            ans.add(0);
        }

        // 开始滑动窗口
        for (int i = len_p; i < len_s; i++) {
            // 移除最左边的字符
            char leftChar = s.charAt(i - len_p);
            windowCount[leftChar - 'a']--;

            // 添加右边新进来的字符
            char rightChar = s.charAt(i);
            windowCount[rightChar - 'a']++;

            // 检查当前窗口是否匹配
            int startIdx = i - len_p + 1;
            if (Arrays.equals(pCount, windowCount)) {
                ans.add(startIdx);
            }
        }

        return ans;
    }
}

未完待续。。。

五月茶
关注
Leetcode HOT 100 (Java 版)
dwtianwen的博客
07-14 1250
一刷 Leetcode HOT 100 记录
【力扣hot100】day1
weixin_45792464的博客
09-06 744
听整理力扣hot100题的解法
力扣HOT100合集
qq_61504864的博客
10-09 1972
对于当前考虑的元素 nums[i]，如果 dp[ j - nums[ i ] ] 为 true，说明可以用前面的元素构成和为 j -nums[ i ] 的子集，那么在加上当前元素 nums[ i ] 的情况下，就可以构成和为 j 的子集，因此 dp[ j ] 更新为 true。这样left往回走会导致错误的结果。最终得到的结果为[[1, 2, 3], [2, 1, 3], [3, 1, 2], [1, 3, 2], [2, 3, 1], [3, 2, 1]]，即给定数组[1, 2, 3]的全排列结果。
力扣HOT100-Java个人题解整理与总结
alian
04-20 4502
LeetCode 热题 HOT 100 1，两数之和 难度简单13695 给定一个整数数组nums和一个整数目标值target，请你在该数组中找出和为目标值target 的那两个整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。 你可以按任意顺序返回答案。 思路： 采用两层遍历法，代码比较简单，单复杂度高、 为了减少时间复杂度，因为题干中说明了，只有一种情况的答案，顾可以采用map<value,index&...
力扣HOT 100
Ziwei_ZHU的博客
04-15 449
定义数组维护滑动窗口，每次更新窗口并找最大值。
算法总结+力扣hot100|回溯
leeyayai_xixihah的博客
06-02 969
nums无重复元素---同一层不可重复取---纵向可以重复取nums无重复元素--所以横向不用去重但纵向重复取？---单层循环中，i不能从0开始。否则：（2，2，3）与（3，2，2）不能从i+1开始（下一层递归传入的），否则取不到重复的nums有重复元素---同一层不可重复取---纵向可以重复取（因为有重复元素）纵向可以重复取（因为有重复元素）？----从i+1开始（下一层递归传入的）横向去重---排序，相同的跳过。
java力扣（hot100）
weixin_50874381的博客
09-13 251
思路：创建一个哈希表，遍历列表，若target-nums[i]在哈希表中，则说明存在，则return，若没有，则把当前位置i和nums[i]放入哈希表，nums[i]为键。一些哈希表中的基本操作。
LeetCode Hot 100 题解[java版本，冲大厂]
m0_46335449的博客
11-15 782
这里记录一下自己刷Leetcodehot100的题目，面试完几家发现自己经常会跑出bug，对于很多算法还是不熟悉，需要继续深入，这里记录自己最喜欢的一个题解，争取遇到这个题目的时候，可以不写出bug。 还有很多工具类的实现，自己还需要多掌握掌握。
力扣HOT100 (1-5)
m0_47743353的博客
02-10 652
1-5
力扣hot100 LeetCode 热题 100 Java 哈希篇
温柔半两，从容一生
04-22 314
【代码】力扣hot100 LeetCode 热题 100 Java 哈希篇。
Leetcode Top100题目和答案（Java完整版 面试必备）.zip
06-03
《LeetCode Top100题目和答案（Java完整版 面试必备）》这个压缩包文件是一个针对Java程序员的面试准备资源，包含了LeetCode上最受欢迎的前100道编程题目及其对应的Java解决方案。LeetCode是一个在线平台，提供了一...
力扣hot100怎么更新
03-16
### 力扣 Hot 100 的更新机制 力扣（LeetCode）的 **Hot 100** 是一个精选题目列表，旨在帮助开发者集中练习最具代表性和挑战性的算法问题。虽然官方并未公开具体的更新机制细节，但从社区讨论和观察可以总结一些...
力扣-94.二叉树的中序遍历
weixin_46878941的博客
05-12 262
小结：做简单题就是心情舒畅，注意单写一个函数就好了。给定一个二叉树的根节点 root ，返回 它的。
LeetCode 55. 跳跃游戏（中等）
ZeroBugX的博客
05-14 765
LeetCode 55. 跳跃游戏 - 详细题解
LeetCode 513 找树左下角的值 LeetCode 112 路径总和 LeetCode106 从中序与后序遍历序列构造二叉树
weixin_59234335的博客
05-12 860
中序遍历 + 前序/后序遍历 可以 确定一个唯一的二叉树。必须有中序遍历的存在。而前序遍历+后序遍历无法确认。前序遍历：中左右后序遍历：左右中根据前序遍历和后序遍历的特性，我们只能唯一确定根节点，但无法从前序遍历和后序遍历划分出左右。例子如下：上面这两颗树的前序遍历都为[ 1, 2, 3] ，后序遍历为[3, 2, 1]
【Leetcode 每日一题】2094. 找出 3 位偶数
冠位优化
05-12 1010
Leetcode 每日一题 - 找出 3 位偶数
每日一道leetcode
XiaoyaoCarter的博客
05-14 759
计算其二进制表示中 1。
LeetCode_sql刷题(3482.分析组织层级)
最新发布
Darling博客
05-14 544
递归查询
力扣HOT100之二叉树：101. 对称二叉树
weixin_52151595的博客
05-12 259
这道题我本来想着挑战一下自己，尝试着用迭代的方法来做，然后就是用层序遍历，将每一层的元素收集到一个临时的一维向量中，然后再逐层判断每一层是否都是轴对称的，一旦发现某一层不是轴对称的，就直接。注意，再判断每一层是否为轴对称时，千万不能用栈来匹配（类似于括号匹配的思路），因为下面的情况用栈会判定为轴对称，但是实际上是非轴对称的。此外，当前层的下一层如果至少有一个非空节点，那么下一层的空节点也必须加入，否则判定也会出问题。的情况，就说明每一层都是轴对称的，此时直接。，当所有的层都遍历结束后，都没有出现。
力扣题top100java版本 pdf
01-26
力扣题top100java版本pdf是一份包含了力扣网站上100道热门题目的java版本的PDF文档。这些题目涵盖了算法、数据结构等多个领域，是程序员学习和提升编程能力的重要资料。 这份PDF提供了java版本的题目描述、示例代码和解题思路，对于想要学习java编程的人来说是非常有用的。通过阅读这份PDF，可以了解到如何使用java语言来解决各种算法和数据结构问题，对于提升编程能力和解题能力都具有很大的帮助。 同时，这份PDF也提供了一个练习和巩固知识的机会。在阅读题目描述和示例代码的过程中，读者可以逐步掌握各种算法和数据结构的应用方法，同时也可以通过尝试自己编写代码来检验自己的理解和掌握程度。 总的来说，力扣题top100java版本pdf是一份对于学习和提升编程能力非常有帮助的资料，适合那些想要深入学习java编程并提升解题能力的人使用。希望更多的人可以通过阅读这份PDF，掌握java编程的技能，提升自己的编程水平。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值