题目一
101. 对称二叉树
给定一个二叉树,检查它是否是镜像对称的。
例如,二叉树 [1,2,2,3,4,4,3] 是对称的。
1
/ \
2 2
/ \ / \
3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
1
/ \
2 2
\ \
3 3
进阶:
你可以运用递归和迭代两种方法解决这个问题吗?
我的答案
递归
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public boolean isSymmetric(TreeNode root) {
return check(root, root);
}
// 检查传过来的左右节点的值左右子树是否相同
public static boolean check(TreeNode leftNode, TreeNode rightNode){
if(leftNode == null && rightNode == null) return true;
if(leftNode == null || rightNode == null) return false;
// 检查
// 左右节点的值
// 左节点的左子树与右节点的右子树
// 左节点的右子树与右节点的左子树
// 是否相等
return leftNode.val == rightNode.val &&
check(leftNode.left, rightNode.right) &&
check(leftNode.right, rightNode.left);
}
}
复杂度分析
假设树上一共 n 个节点。
时间复杂度:这里遍历了这棵树,渐进时间复杂度为 O(n)。
空间复杂度:这里的空间复杂度和递归使用的栈空间有关,这里递归层数不超过 n,故渐进空间复杂度为 O(n)。
我认为的迭代
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public boolean isSymmetric(TreeNode root) {
if (root == null) return true;
TreeNode rootroot = root; // 用于标记最顶层根节点
TreeNode root2 = root; // 复制一份引用
Stack<TreeNode> stack = new Stack<>();
Stack<TreeNode> stack2 = new Stack<>();
// 一个栈装左子树,一个栈装右子树
// 就是一边直冲最底层左子树,一边直冲最右右子树
// 就是类似中序遍历一样,左右子树只不过是相反的而已
while(!stack.isEmpty() || !stack2.isEmpty() || root != null || root2 != null){
int leftVal = 0, rightVal = 0;
while(root != null){
stack.push(root); // 把本身放进栈
root = root.left;
// 出这个循环说明达到最左边的节点了
}
while(root2 != null){
stack2.push(root2); // 把本身放进栈
root2 = root2.right;
// 出这个循环说明达到最右边的节点了
}
// 弹出最上面的节点(即为上行代码比较值的节点)
root = stack.pop();
root2 = stack2.pop();
leftVal = root.val; // 记录值
rightVal = root2.val; // 记录值
System.out.println(leftVal + " - " + rightVal);
// 在判断值前先判断两个栈内的元素是否一样多,对称树应该时一样多的
if(stack.size() != stack2.size()) return false;
if (leftVal != rightVal) return false; // 判断左右值,不同即false
// 有一个回到顶层节点另一个却没回到顶层节点时直接返回false
if(root == rootroot && root2 != rootroot) return false;
if(root2 == rootroot && root != rootroot) return false;
// 判断是否回到了最顶层根节点
if(root == root2) return true; // 回到了说明左右子树一样,这时就必要再往下判断了
// 没回到最顶层根节点,就要判断左子树的右节点和右子树的左节点值是否相同
root = root.right;
root2 = root2.left;
}
return stack.isEmpty() && stack2.isEmpty();
}
}
正确的迭代
class Solution {
public boolean isSymmetric(TreeNode root) {
return check(root, root);
}
public boolean check(TreeNode u, TreeNode v) {
Queue<TreeNode> q = new LinkedList<TreeNode>();
q.offer(u);
q.offer(v);
while (!q.isEmpty()) {
u = q.poll();
v = q.poll();
if (u == null && v == null) {
continue;
}
if ((u == null || v == null) || (u.val != v.val)) {
return false;
}
q.offer(u.left);
q.offer(v.right);
q.offer(u.right);
q.offer(v.left);
}
return true;
}
}
复杂度分析
时间复杂度:O(n),同「递归」。
空间复杂度:这里需要用一个队列来维护节点,每个节点最多进队一次,出队一次,队列中最多不会超过 n 个点,故渐进空间复杂度为 O(n)。
题目二
112. 路径总和
给定一个二叉树和一个目标和,判断该树中是否存在根节点到叶子节点的路径,这条路径上所有节点值相加等于目标和。
说明: 叶子节点是指没有子节点的节点。
示例:
给定如下二叉树,以及目标和 sum = 22,
5
/ \
4 8
/ / \
11 13 4
/ \ \
7 2 1
返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。
我的答案
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public boolean hasPathSum(TreeNode root, int sum) {
return root != null && maxValue(root, 0, sum); // 添加进去了说明没有这个路径值,就取反为false
}
public boolean maxValue(TreeNode node, int n, int sum){
if (node == null) return false;
if (node.left == null && node.right == null){
// 说明到叶子节点了,判断此时和会不会等于sum
n += node.val;
return n == sum;
}else{
// 不为null就往下继续找节点
n += node.val;
return maxValue(node.left, n, sum) || maxValue(node.right, n, sum);
}
}
}
广度优先算法
class Solution {
public boolean hasPathSum(TreeNode root, int sum) {
if (root == null) {
return false;
}
Queue<TreeNode> queNode = new LinkedList<TreeNode>();
Queue<Integer> queVal = new LinkedList<Integer>();
queNode.offer(root);
queVal.offer(root.val);
while (!queNode.isEmpty()) {
TreeNode now = queNode.poll();
int temp = queVal.poll();
if (now.left == null && now.right == null) {
if (temp == sum) {
return true;
}
continue;
}
if (now.left != null) {
queNode.offer(now.left);
queVal.offer(now.left.val + temp);
}
if (now.right != null) {
queNode.offer(now.right);
queVal.offer(now.right.val + temp);
}
}
return false;
}
}
复杂度分析
时间复杂度:O(N),其中 NN 是树的节点数。对每个节点访问一次。
空间复杂度:O(N),其中 NN 是树的节点数。空间复杂度主要取决于队列的开销,队列中的元素个数不会超过树的节点数。
递归
class Solution {
public boolean hasPathSum(TreeNode root, int sum) {
if (root == null) {
return false;
}
if (root.left == null && root.right == null) {
return sum == root.val;
}
return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
}
}
复杂度分析
时间复杂度:O(N),其中 NN 是树的节点数。对每个节点访问一次。
空间复杂度:O(H),其中 HH 是树的高度。空间复杂度主要取决于递归时栈空间的开销,最坏情况下,树呈现链状,空间复杂度为 O(N)。平均情况下树的高度与节点数的对数正相关,空间复杂度为 O(\log N)。
题目三
1656. 设计有序流
有 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 。
否则,返回一个空列表。
示例:
图片来自于leetcode,侵删。
输入
[“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 <= 1000
1 <= id <= n
value.length == 5
value 仅由小写字母组成
每次调用 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);
*/
我的思路不是很清晰。
别人清晰的解答
解题思路
难点就在于ptr的指向位置,从动图可以直接看出来,ptr表示的是连续有值的序列的下一位。
即从ptr往流的末尾开始遍历,遇到空的就停止,不空就+1;
class OrderedStream {
String[] stream;
int ptr = 0;
public OrderedStream(int n) {
// 根据长度创建String数组保存值
stream = new String[n];
}
public List<String> insert(int id, String value) {
// id从1起始,所以减1
stream[id-1] = value;
// 要返回的数组
List<String> list = new ArrayList<>();
// 从ptr开始,直到数组的末尾
for (int i = ptr; i < stream.length; i++) {
// 如果遇到流中的空值,跳出循环直接返回list
if (stream[i] == null) {
break;
} else { // 如果该处不为空值,那么ptr就可以到这个地方,返回的list中也应包括这个值
ptr++;
list.add(stream[i]);
}
}
return list;
}
}
/**
* Your OrderedStream object will be instantiated and called as such:
* OrderedStream obj = new OrderedStream(n);
* List<String> param_1 = obj.insert(id,value);
*/
作者:Fisnake
链接:https://leetcode-cn.com/problems/design-an-ordered-stream/solution/javashuang-bai-gen-ju-ti-yi-fan-yi-jiu-hao-shi-xia/
来源:力扣(LeetCode)
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。