本文详细介绍了如何使用Java解决四道LeetCode算法题：包括求解二叉树的最大深度、解密具有循环性质的数组、设计有序流类以及判断两个字符串是否接近。每道题目都提供了详细的解题思路和代码实现，有助于提升算法思维和编程技巧。
题目一
104. 二叉树的最大深度
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
3
/ \
9 20
/ \
15 7
返回它的最大深度 3 。
我的答案
递归
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public int maxDepth(TreeNode root) {
if(root == null) return 0;
int leftDepth = maxDepth(root.left);
int rightDepth = maxDepth(root.right);
return Math.max(leftDepth, rightDepth) + 1;
}
}
题目二
5550. 拆炸弹
你有一个炸弹需要拆除，时间紧迫！你的情报员会给你一个长度为 n 的 循环 数组 code 以及一个密钥 k 。
为了获得正确的密码，你需要替换掉每一个数字。所有数字会 同时 被替换。
如果 k > 0 ，将第 i 个数字用 接下来 k 个数字之和替换。
如果 k < 0 ，将第 i 个数字用 之前 k 个数字之和替换。
如果 k == 0 ，将第 i 个数字用 0 替换。
由于 code 是循环的， code[n-1] 下一个元素是 code[0] ，且 code[0] 前一个元素是 code[n-1] 。
给你 循环 数组 code 和整数密钥 k ，请你返回解密后的结果来拆除炸弹！
示例 1：
输入：code = [5,7,1,4], k = 3
输出：[12,10,16,13]
解释：每个数字都被接下来 3 个数字之和替换。解密后的密码为 [7+1+4, 1+4+5, 4+5+7, 5+7+1]。注意到数组是循环连接的。
示例 2：
输入：code = [1,2,3,4], k = 0
输出：[0,0,0,0]
解释：当 k 为 0 时，所有数字都被 0 替换。
示例 3：
输入：code = [2,4,9,3], k = -2
输出：[12,5,6,13]
解释：解密后的密码为 [3+9, 2+3, 4+2, 9+4] 。注意到数组是循环连接的。如果 k 是负数，那么和为 之前 的数字。
提示：
n == code.length
1 <= n <= 100
1 <= code[i] <= 100
-(n - 1) <= k <= n - 1
我的答案
class Solution {
public int[] decrypt(int[] code, int k) {
int[] ret = new int[code.length];
if (k == 0) return ret;
for(int i=0; i<code.length; i++){
// i是每位指针
int sum = 0;
if(k > 0){
// 从当前位的后k为之和
for(int j=1; j<=k;j++){ // 保证每次只控制k次循环
if((i+j) >= code.length){ // 大于code长度说明要从索引0再开始读了
sum +=code[((i+j)-code.length)];
}else{
sum += code[i+j];
}
}
}else{
for(int j=code.length-1; j>=(code.length+k);j--){
if((i+j) > (code.length-1)){ // 大于说明
sum += code[i+j-code.length];
}else{
sum += code[j+i];
}
}
}
ret[i] = sum;
}
return ret;
}
}
题目三
5601. 设计有序流
有 n 个 (id, value) 对，其中 id 是 1 到 n 之间的一个整数，value 是一个字符串。不存在 id 相同的两个 (id, value) 对。
设计一个流，以 任意 顺序获取 n 个 (id, value) 对，并在多次调用时 按 id 递增的顺序 返回一些值。
实现 OrderedStream 类：
OrderedStream(int n) 构造一个能接收 n 个值的流，并将当前指针 ptr 设为 1 。
String[] insert(int id, String value) 向流中存储新的 (id, value) 对。存储后：
如果流存储有 id = ptr 的 (id, value) 对，则找出从 id = ptr 开始的 最长 id 连续递增序列 ，并 按顺序 返回与这些 id 关联的值的列表。然后，将 ptr 更新为最后那个 id + 1 。
否则，返回一个空列表。
输入
["OrderedStream", "insert", "insert", "insert", "insert", "insert"]
[[5], [3, "ccccc"], [1, "aaaaa"], [2, "bbbbb"], [5, "eeeee"], [4, "ddddd"]]
输出
[null, [], ["aaaaa"], ["bbbbb", "ccccc"], [], ["ddddd", "eeeee"]]
解释
OrderedStream os= new OrderedStream(5);
os.insert(3, "ccccc"); // 插入 (3, "ccccc")，返回 []
os.insert(1, "aaaaa"); // 插入 (1, "aaaaa")，返回 ["aaaaa"]
os.insert(2, "bbbbb"); // 插入 (2, "bbbbb")，返回 ["bbbbb", "ccccc"]
os.insert(5, "eeeee"); // 插入 (5, "eeeee")，返回 []
os.insert(4, "ddddd"); // 插入 (4, "ddddd")，返回 ["ddddd", "eeeee"]
提示：
1 <= n <= 10001 <= id <= nvalue.length == 5value仅由小写字母组成- 每次调用
insert都会使用一个唯一的id - 恰好调用
n次insert
我的答案
class OrderedStream {
String[] ret;
int ptr = 0;
public OrderedStream(int n) {
this.ptr = 1;
ret = new String[n];
}
public List<String> insert(int id, String value) {
ret[id-1] = value; // 先添加值
List<String> retList = new ArrayList<>();
// 返回值，从当前指针往后所有长度的
for(int i=ptr-1; i<ret.length; i++){
System.out.println("i:" + i + ", id:" + id+ ", ptr: " + ptr) ;
if((id != ptr || ret[i] == null) && ret[ptr-1] == null){
break;
}else{
retList.add(ret[i]);
ptr++;
// System.out.println("" + retList + ", " + ptr);
}
}
return retList;
}
}
/**
* Your OrderedStream object will be instantiated and called as such:
* OrderedStream obj = new OrderedStream(n);
* List<String> param_1 = obj.insert(id,value);
*/
题目四
- 确定两个字符串是否接近
如果可以使用以下操作从一个字符串得到另一个字符串，则认为两个字符串 接近 ：
操作 1：交换任意两个 现有 字符。
例如，abcde -> aecdb
操作 2：将一个 现有 字符的每次出现转换为另一个 现有 字符，并对另一个字符执行相同的操作。
例如，aacabb -> bbcbaa（所有 a 转化为 b ，而所有的 b 转换为 a ）
你可以根据需要对任意一个字符串多次使用这两种操作。
给你两个字符串，word1 和 word2 。如果 word1 和 word2 接近 ，就返回 true ；否则，返回 false 。
示例 1：
输入：word1 = "abc", word2 = "bca"
输出：true
解释：2 次操作从 word1 获得 word2 。
执行操作 1："abc" -> "acb"
执行操作 1："acb" -> "bca"
示例 2：
输入：word1 = "a", word2 = "aa"
输出：false
解释：不管执行多少次操作，都无法从 word1 得到 word2 ，反之亦然。
示例 3：
输入：word1 = "cabbba", word2 = "abbccc"
输出：true
解释：3 次操作从 word1 获得 word2 。
执行操作 1："cabbba" -> "caabbb"
执行操作 2："caabbb" -> "baaccc"
执行操作 2："baaccc" -> "abbccc"
示例 4：
输入：word1 = "cabbba", word2 = "aabbss"
输出：false
解释：不管执行多少次操作，都无法从 word1 得到 word2 ，反之亦然。
提示：
1 <= word1.length, word2.length <= 105word1和word2仅包含小写英文字母
我的答案
class Solution {
public boolean closeStrings(String word1, String word2) {
if(word1 == null || word2 == null || word1.length() != word2.length())
return false;
Map<Character, Integer> wordMap1 = new HashMap<>();
Map<Character, Integer> wordMap2 = new HashMap<>();
for(int i = 0; i < word1.length(); i++){
if(!wordMap1.containsKey(word1.charAt(i))){
wordMap1.put(word1.charAt(i), 1);
}else{
wordMap1.put(word1.charAt(i), wordMap1.get(word1.charAt(i))+1);
}
}
for(int i = 0; i < word2.length(); i++){
if(!wordMap1.containsKey(word2.charAt(i))){
return false;
}
if(!wordMap2.containsKey(word2.charAt(i))){
wordMap2.put(word2.charAt(i), 1);
}else{
wordMap2.put(word2.charAt(i), wordMap2.get(word2.charAt(i))+1);
}
}
for(int i = 0; i < word1.length(); i++) {
if (!wordMap2.containsKey(word1.charAt(i))) {
return false;
}
}
java.util.Collection<Integer> values = wordMap1.values();
java.util.Collection<Integer> values2 = wordMap2.values();
List<Integer> l1 = new ArrayList<>();
l1.addAll(values);
List<Integer> l2 = new ArrayList<>();
l2.addAll(values2);
System.out.println(l1);
System.out.println(l2);
java.util.Collections.sort(l1);
java.util.Collections.sort(l2);
if(!l1.equals(l2)){
return false;
}
return true;
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
