Sponsored
Sponsored
Time Complexity: O(n), where n is the number of nodes in the binary tree.
Space Complexity: O(h), where h is the height of the tree due to the recursion stack.
1public class TreeNode {
2 public int val;
3 public TreeNode left;
4 public TreeNode right;
5 public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
6 this.val = val;
7 this.left = left;
8 this.right = right;
9 }
10}
11
12public class Solution {
13 private int Dfs(TreeNode node, int maxVal) {
14 if (node == null) return 0;
15 int good = (node.val >= maxVal) ? 1 : 0;
16 maxVal = Math.Max(maxVal, node.val);
17 good += Dfs(node.left, maxVal);
18 good += Dfs(node.right, maxVal);
19 return good;
20 }
21
22 public int GoodNodes(TreeNode root) {
23 return Dfs(root, root.val);
24 }
25}
26
This C# implementation defines a private recursive method Dfs
that is called from the public method GoodNodes
. It counts the nodes that are considered good.
Time Complexity: O(n), where n is the number of nodes in the tree.
Space Complexity: O(w), where w is the maximum width of the tree.
using System.Collections.Generic;
public class TreeNode {
public int val;
public TreeNode left;
public TreeNode right;
public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
this.val = val;
this.left = left;
this.right = right;
}
}
public class Solution {
public int GoodNodes(TreeNode root) {
if (root == null) return 0;
Queue<(TreeNode, int)> queue = new Queue<(TreeNode, int)>();
queue.Enqueue((root, root.val));
int goodCount = 0;
while (queue.Count > 0) {
(TreeNode node, int maxVal) = queue.Dequeue();
if (node.val >= maxVal) goodCount++;
if (node.left != null) queue.Enqueue((node.left, Math.Max(maxVal, node.val)));
if (node.right != null) queue.Enqueue((node.right, Math.Max(maxVal, node.val)));
}
return goodCount;
}
}
In this C# solution, a queue is used to implement BFS, with each item being a tuple that contains both the current node and the maximum value encountered so far. The process checks each node, updating the count of good nodes as necessary.