Java - LeetCode面试经典150题(二)

已于 2024-09-28 09:35:05 修改
阅读量385 收藏 4
点赞数 7
分类专栏： Java知识专栏 文章标签： leetcode java 面试
于 2024-09-28 09:34:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74403543/article/details/142610948
版权

哈希表

383. 赎金信

题目

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。

提示：

1 <= ransomNote.length, magazine.length <= 1e5
ransomNote 和 magazine 由小写英文字母组成

示例 1：
输入：ransomNote = "a", magazine = "b"
输出：false
示例 2：
输入：ransomNote = "aa", magazine = "ab"
输出：false
示例 3：
输入：ransomNote = "aa", magazine = "aab"
输出：true
解析：

将magazine中的每个字符的个数记录下来，用map映射成<字符，对应字符个数>。
然后遍历ransomNote字符，判断magazine剩下的字符是否能够组成ransomNote的字符。

代码：
class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        Map<Character, Integer> m = new HashMap<>();
        for (int i=0;i<magazine.length();i++){
            Character c=magazine.charAt(i);
            if (m.containsKey(c)){
                m.put(c,m.get(c)+1);
            }
            else{
                m.put(c,1);
            }
        }
        for (int i=0;i<ransomNote.length();i++){
            Character c=ransomNote.charAt(i);
            if (m.containsKey(c)&&m.get(c)>0){
                m.put(c,m.get(c)-1);
            }
            else return false;
        }
        return true;
    }
}

205. 同构字符串

题目

给定两个字符串 s 和 t ，判断它们是否是同构的。
如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。
每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。

提示：

1 <= s.length <= 5 * 104
t.length == s.length
s 和 t 由任意有效的 ASCII 字符组成

示例 1:
输入：s = "egg", t = "add"
输出：true
示例 2：
输入：s = "foo", t = "bar"
输出：false
示例 3：
输入：s = "paper", t = "title"
输出：true
解析：

首先判断两个字符串的长度是否相等，不相等肯定不同构。
之后就是遍历字符串，对应字符判断。
我用的两个map，记录对方信息 map<自己字符，对方字符>
当遍历字符，并从map中取出对应字符c,d时，会出现下面的情况：

  1. c和d都为null，此时加入map中，continue；

  2. c和d有一个为空，此时就是说明有一个被占用，false；

  3. c和d都不为空，但是不相等，false；

  4. c和d都不为空，且相等，continue；

能遍历完字符串，就是 true；

代码：
class Solution {
    public boolean isIsomorphic(String s, String t) {
        int n=s.length(),m=t.length();
        if (n!=m){
            return false;
        }
        HashMap<Character,Character> q=new HashMap<>();
        HashMap<Character,Character> p=new HashMap<>();
        boolean flag=true;
        for (int i=0,j=0;i<n;i++,j++){
            Character c=q.get(s.charAt(i));
            Character d=p.get(t.charAt(j));
            // System.out.println(c);
            if (c==null&&d==null){
                q.put(s.charAt(i),t.charAt(j));
                p.put(t.charAt(j),s.charAt(i));
            }
            else if (c==null||d==null){
                flag=false;
                return flag;
            }
            else if (c==t.charAt(j)){
                continue;
            }
            else{
                flag=false;
                return flag;
            }
        }
        return flag;
    }
}

290. 单词规律

题目

给定一种规律 pattern 和一个字符串 s ，判断 s 是否遵循相同的规律。
这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。

提示:

1 <= pattern.length <= 300
pattern 只包含小写英文字母
1 <= s.length <= 3000
s 只包含小写英文字母和 ' '
s 不包含 任何前导或尾随对空格
s 中每个单词都被 单个空格 分隔

示例1:
输入: pattern = "abba", s = "dog cat cat dog"
输出: true
示例 2:
输入:pattern = "abba", s = "dog cat cat fish"
输出: false
示例 3:
输入: pattern = "aaaa", s = "dog cat cat dog"
输出: false
解析：

可以使用两个map，做到字符和字符串相互映射，保证同时合法。

代码：
class Solution {
    public boolean wordPattern(String pattern, String s) {
        String[] str=s.split(" ");
        int n=pattern.length();
        if (n!=str.length) return false;
        HashMap<Character, String> q = new HashMap<>();
        HashMap<String, Character> p = new HashMap<>();
        for (int i=0;i<n;i++){
            Character cha=p.get(str[i]);
            String st=q.get(pattern.charAt(i));
            if (cha==null&&st==null){
                q.put(pattern.charAt(i),str[i]);
                p.put(str[i],pattern.charAt(i));
                continue;
            }
            else if (cha!=null&&st!=null&&cha==pattern.charAt(i)&&st.equals(str[i])){
                continue;
            }
            else{
                return false;
            }
        }
        return true;
    }
}

242. 有效的字母异位词

题目

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的 字母异位词。

提示:

1 <= s.length, t.length <= 5 * 1e4
s 和 t 仅包含小写字母

示例 1:
输入: s = "anagram", t = "nagaram"
输出: true
示例 2:
输入: s = "rat", t = "car"
输出: false
解析：

用map<Character,Integer>，将字符串 s 的一个字符出现的次数记录下来。
遍历t串，看剩下的相同字符是否大于0。

代码：
class Solution {
    public boolean isAnagram(String s, String t) {
        int n=s.length();
        if (n!=t.length()) return false;
        HashMap<Character, Integer> q = new HashMap<>();
        for (int i=0;i<n;i++){
            Integer x=q.get(s.charAt(i));
            if (x==null) x=1;
            else x++;
            q.put(s.charAt(i),x);
        }
        for (int i=0;i<n;i++){
            if (q.containsKey(t.charAt(i))&&q.get(t.charAt(i))>0){
                Integer x=q.get(t.charAt(i));
                q.put(t.charAt(i),x-1);
            }
            else return false;
        }
        return true;
    }
}

49. 字母异位词分组

题目

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。
字母异位词 是由重新排列源单词的所有字母得到的一个新单词。

提示：

1 <= strs.length <= 1e4
0 <= strs[i].length <= 100
strs[i] 仅包含小写字母

示例 1:
输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
示例 2:
输入: strs = [""]
输出: [[""]]
示例 3:
输入: strs = ["a"]
输出: [["a"]]
解析：

用map哈希，<String,List<String>>
遍历字符串数组，将其中的字符串，进行排序，这样就形成一个唯一的字符串了，之后将原字符串追加到这个排序完的字符串映射的String列表中。

代码：
import java.util.*;
class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        int n=strs.length;
        Map<String, List<String>> m = new HashMap<>();
        for (int i=0;i<n;i++){
            String s=strs[i];
            char[] q=s.toCharArray();
            Arrays.sort(q);
            String ss=Arrays.toString(q);
            // if (m.containsKey(ss)){
            //     var p=m.get(ss);
            //     p.add(s);
            // }
            // else{
            //     List<String> p = new ArrayList<>();
            //     m.put(ss,p);
            //     p.add(s);
            // }
            //下方代码可替换上面注释掉的代码
            List<String> list = m.getOrDefault(ss, new ArrayList<String>());
            list.add(s);
            m.put(ss, list);
        }
        // List<List<String>> ans = new ArrayList<>();
        // Collection<List<String>> values = m.values();
        // for (var x:values){
        //     ans.add(x);
        //     for (var y:x){
        //         System.out.print(y+" ");
        //     }
        //     System.out.println();
        // }
        // return ans;
        //下方代码可替换上面注释掉的代码
        return new ArrayList<List<String>>(m.values());
    }
}

1. 两数之和

题目

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。
你可以按任意顺序返回答案。

提示：

2 <= nums.length <= 1e4
-1e9 <= nums[i] <= 1e9
-1e9 <= target <= 1e9
只会存在一个有效答案

示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]
解析：

没使用双for循环，也不知道会不会暴。
使用 Map<Integer, List<Integer>>，遍历数组将相同数字的下标放在一个列表中。
之后通过遍历数组，判断能不能找到target-nums[i]这个值得数，且要判断该值所在的这些ID，是否等于 i。
找到之后，i和ID就是答案。

代码：
class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, List<Integer>> m = new HashMap<>();
        int n=nums.length;
        int[] ans=new int[2];
        for (int i=0;i<n;i++) {
            // if (m.containsKey(nums[i])){
            //     var q=m.get(nums[i]);
            //     q.add(i);
            // }
            // else{
            //     ArrayList<Integer> q = new ArrayList<>();
            //     m.put(nums[i],q);
            //     q.add(i);
            // }
            List<Integer> list = m.getOrDefault(nums[i], new ArrayList<Integer>());
            list.add(i);
            m.put(nums[i], list);
        }
        for (int i=0;i<n;i++) {
            int k=target-nums[i];
            if (m.containsKey(k)){
                List<Integer> q=m.get(k);
                for (Integer x:q){
                    if (x!=i){
                        ans[0]=i;
                        ans[1]=x;
                        return ans;
                    }
                }
            }
        }
        return ans;
    }
}

202. 快乐数

题目

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

  • 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果这个过程 结果为 1，那么这个数就是快乐数。

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

提示：

1 <= n <= 231 - 1

示例 1：
输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1
示例 2：
输入：n = 2
输出：false
解析：

按照题意进行编写即可。
将出现过的数记录下来，如果该数再次出现，就说明这是一个无限循环，false了。

代码：
class Solution {
    public static boolean isHappy(int n) {
        HashSet<Integer> k = new HashSet<Integer>();
        boolean flag=false;
        while (true){
//            System.out.println(n);
            if (n==1){
                flag=true;
                break;
            }
            if (k.contains(n)) break;
            k.add(n);
            int res=0;
            while (n>0){
                int l=n%10;
                res=res+l*l;
                n /=10;
            }
            n=res;
        }
        return flag;
    }
}
 

219. 存在重复元素 II

题目

给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在，返回 true ；否则，返回 false 。

提示：

1 <= nums.length <= 1e5
-1e9 <= nums[i] <= 1e9
0 <= k <= 1e5

示例 1：
输入：nums = [1,2,3,1], k = 3
输出：true
示例 2：
输入：nums = [1,0,1,1], k = 1
输出：true
示例 3：
输入：nums = [1,2,3,1,2,3], k = 2
输出：false
解析：

遍历数组，将值相同的id，放在一个列表中。因为遍历数组，所以同一个列表中的id值，肯定是递增的。所以只需要判断一个列表中相邻的id大小即可。
判断存在就是存在；如果没有，最近的都没有了，就肯定没有了。

代码：
import java.util.Collection;
class Solution {
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        int n=nums.length;
        HashMap<Integer, List<Integer>> m = new HashMap<Integer, List<Integer>>();
        for (int i=0;i<n;i++){
            if (m.containsKey(nums[i])){
                var q=m.get(nums[i]);
                q.add(i);
            }
            else{
                ArrayList<Integer> q = new ArrayList<>();
                m.put(nums[i],q);
                q.add(i);
            }
        }
        boolean flag=false;
        Collection<List<Integer>> res = m.values();
        for (List<Integer> q:res){
            for (int i=0;i<q.size()-1;i++){
                if (Math.abs(q.get(i)-q.get(i+1))<=k){
                    flag=true;
                    return true;
                }
            }
        }
        return flag;
    }
}

128. 最长连续序列

题目

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

提示：

0 <= nums.length <= 1e5
-1e9 <= nums[i] <= 1e9

示例 1：
输入：nums = [100,4,200,1,3,2]
输出：4
解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。
示例 2：
输入：nums = [0,3,7,2,5,8,4,6,0,1]
输出：9
解析：

利用TreeSet的不可重复性，和能内置一个比较器的特点，就可以解决该题，但是时间复杂度是O(nlog(n))。

代码：
class Solution {
        public int longestConsecutive(int[] nums) {
        TreeSet<Integer> k = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });
        int n=nums.length;
        for (int i=0;i<n;i++) k.add(nums[i]);
//        System.out.println(k);
        List<Integer> ans = new ArrayList<>(k);
        if (ans.size()==0){
            return 0;
        }
        int cnt=1,res=1;
        for (int i=1;i<ans.size();i++){
            if (ans.get(i)==ans.get(i-1)+1){
                cnt++;
            }
            else{
                res=Math.max(res,cnt);
                cnt=1;
            }
        }
        res=Math.max(res,cnt);
        return res;
    }
}
OLDERHARD
关注
专栏目录
java-leetcode面试题解Stack之第150题逆波兰表达式求值-题解.zip
05-05
本题是LeetCode中的第150题，主要考察Java程序员对栈（Stack）数据结构的理解以及其在解决实际问题中的应用。LeetCode作为程序员面试的热门平台，此类题目对于准备求职面试的开发者来说至关重要。 首先，我们需要...
java-leetcode面试题解哈希表第349题两个数组的交集-题解.zip
03-26
标题中的“java-leetcode面试题解哈希表第349题两个数组的交集-题解.zip”表明这是一个关于Java编程语言的LeetCode面试题解答，具体是针对第349题，该题目涉及使用哈希表解决两个数组的交集问题。LeetCode是一个知名...
【Leetcode：面试经典150题】（1-10题）解析
dreaming_creator的博客
03-03 3542
该部分内容主要讲解Leetcode网站中，面试经典150题中1-10题，该部分主要包括动态数组、排序、双指针、贪心和动态规划的内容。每题包括题目描述、示例、提示、部分模拟计算、代码实现和结果展示。 笔者参加过一些算法竞赛，有些微薄见解如下：在学习算法的过程中，我们通常会进行题型分类学习，如动态规划问题，我们首先会做一些相关例题，主要学习什么题适合动态规划解决以及如何设动态规划计算法思路两个方面。但我们对于未学习的算法有时候初步学习的时候有较大难度，因此笔者认为模拟计算是一个很好的方式。
Leetcode面试经典150题-74.搜索二维矩阵
个人专长：数据结构和算法、大数据、数据库、主流框架
09-10 606
Leetcode面试经典150题-74.搜索二维矩阵，同时也是字节面试高频题，务必掌握
LeetCode面试经典150题--第二题：移除元素（Java）
m0_63549623的博客
01-09 389
将数组中与val不同的元素直接从0位置开始覆盖就可以了。定义一个指针指向0索引位置，覆盖一个向右移动一个位置。
【Leetcode面试经典150题】169. 多数元素-Java-摩尔投票
weixin_62183807的博客
09-25 326
【Leetcode面试经典150题】169. 多数元素，Java实现，摩尔投票方法
LeetCode面试经典150题--第五题：多数元素-摩尔投票算法（Java）
m0_63549623的博客
01-22 711
从第二个元素循环遍历，如果当前元素和候选人一样则投票数+1，如果不一样且投票数大于零的时候投票数-1，如果不一样且投票数为零时，重置候选人为当前元素，投票数为1。当指针指向第一个元素时，候选人为：1，得票数为：1，当指针指向第二个元素时，候选人为：1，得票数为：0，当指针指向第三个元素时，候选人为：3，得票数为：1，当指针指向第四个元素时，候选人为：3，得票数为：2，当指针指向第五个元素时，候选人为：3，得票数为：1，当指针指向第七个元素时，候选人为：3，得票数为：1，
Leetcode面试经典150题-172.阶乘后的零
个人专长：数据结构和算法、大数据、数据库、主流框架
09-20 530
Leetcode面试经典150题-172.阶乘后的零，字节跳动高频面试题啊，抖音和头条都考过，务必掌握
LeetCode面试经典150题--第七题：买卖股票的最佳时机（Java）
m0_63549623的博客
01-23 413
遍历数组，如果当前元素小于最小值就更新最小值为当前元素，如果当前元素减去最小值得到的值（利润）大于最大利润，更新最大利润的值。遍历结束就得到了最大利润。定义一个最小值初始化为数组的第一个元素，定义最大利润初始化为0。遍历数组，更新最小值和最大利润。
【leetcode面试经典150题】-45. 跳跃游戏 II
bblb的博客
06-06 575
【leetcode面试经典150题】-45. 跳跃游戏 II
Leetcode面试经典150题-14.最长公共前缀
个人专长：数据结构和算法、大数据、数据库、主流框架
08-18 260
Leetcode面试经典150题-14.最长公共前缀，很简单的题，务必掌握，务必掌握
LeetCode面试经典150题--第八题：买卖股票的最佳时机Ⅱ（Java）
m0_63549623的博客
02-17 454
定义一个变量最大利润初始化为0，从1索引开始遍历数组，如果当前元素比前一个元素大，求出利润累加到最大利润上。
java-leetcode面试题解Stack之第71题简化路径-题解.zip
05-05
标题中的“java-leetcode面试题解Stack之第71题简化路径-题解.zip”指出这是一个关于Java编程语言，LeetCode在线编程平台上的面试题目，具体是第71题，涉及的数据结构是栈（Stack），内容是解答如何简化路径的问题。...
java-leetcode面试题解双指针之第15题三数之和.zip
03-25
本压缩包文件“java-leetcode面试题解双指针之第15题三数之和.zip”包含了解决这道问题的Java代码实现。 题目描述：给定一个包含n个整数的数组nums，判断nums中是否存在三个元素a，b，c，使得a + b + c = 0？要求找...
java-leetcode面试题解哈希表第1题两数之和-题解.zip
03-26
标题中的“两数之和”是LeetCode平台上的一道经典面试题目，主要考察的是使用哈希表解决算法问题的能力。这道题目要求我们从一个整数数组中找到两个数，使得它们的和等于一个给定的目标值。接下来，我将详细讲解这个...
力扣 困难 154.寻找旋转排序数组中的最小值 II
qq_51352130的博客
09-23 376
153.寻找旋转排序数组中的最小值在此基础上，进行二分之前，单独处理一下左指针和最后一个数相同的情况就好了。left++;} else {
leetcode226. 翻转二叉树
最新发布
Turboyiyi的博客
09-27 116
递归翻转二叉树
C++速通LeetCode中等第25题-验证二叉搜索树（中序遍历堆栈迭代法）
lyx的博客
09-23 258
中序遍历堆栈迭代法
[leetcode]113_路径总和II_输出所有路径
weixin_45653183的博客
09-24 389
leetcode 的 Python 代码——处理输入输出；仅记录便于以后自查自学使用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值