DFS grind

Author: Zanger67

README.md

@@ -0,0 +1,23 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def maxAncestorDiff(self, root: Optional[TreeNode]) -> int:
+        def helper(curr: Optional[TreeNode], minn: int, maxx: int) -> int :
+            if not curr :
+                return maxx - minn
+
+            if curr.val < minn :
+                minn = curr.val
+            if curr.val > maxx :
+                maxx = curr.val
+
+            return max(maxx - minn, 
+                        helper(curr.left, minn, maxx), 
+                        helper(curr.right, minn, maxx))
+
+
+        return helper(root, root.val, root.val)

my-submissions/m1026.py

@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+
+int adjustNodeValues(struct TreeNode* root, int addVal) {
+    int add = root->val + addVal;
+    if (root->right) {
+        add += adjustNodeValues(root->right, addVal) - addVal;
+    }
+
+    root->val = add;
+
+    if (root->left) {
+        add += adjustNodeValues(root->left, add) - add;
+    }
+
+    return add;
+}
+
+struct TreeNode* bstToGst(struct TreeNode* root) {
+    adjustNodeValues(root, 0);
+    return root;
+}

my-submissions/m1038.c

@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+
+int output;
+
+long helper(struct TreeNode* root) {
+    if (!root) {
+        return 0;
+    }
+
+    long sum = helper(root->left) + helper(root->right);
+
+    if (root->val == sum) {
+        output++;
+    }
+
+    return sum + root->val;
+}
+
+
+int equalToDescendants(struct TreeNode* root) {
+    output = 0;
+    helper(root);
+
+    return output;
+}

my-submissions/m1973.c

@@ -0,0 +1,33 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def reverseOddLevels(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if not root or not root.left :  # we are promised that every level is filled
+            return root
+
+        level = 0
+        nodes = (deque(), deque())
+
+        nodes[0].append(root.left)
+        nodes[0].append(root.right)
+
+        while nodes[level] :
+            if nodes[level][0].left and nodes[level][0].left.left :
+                for node in nodes[level] :
+                    nodes[(level + 1) % 2].append(node.left.left)
+                    nodes[(level + 1) % 2].append(node.left.right)
+                    nodes[(level + 1) % 2].append(node.right.left)
+                    nodes[(level + 1) % 2].append(node.right.right)
+
+            while nodes[level] :
+                nodes[level][0].val, nodes[level][-1].val = nodes[level][-1].val, nodes[level][0].val
+                nodes[level].popleft()
+                nodes[level].pop()
+
+            level = (level + 1) % 2
+
+        return root

my-submissions/m2415 v1 level order.py

@@ -0,0 +1,36 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def reverseOddLevels(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+
+        vals = []
+
+        def firstPass(curr: Optional[TreeNode], level: int) -> None :
+            if curr.left :
+                firstPass(curr.left, level + 1)
+
+            if level % 2 :
+                vals.append(curr.val)
+
+            if curr.left :
+                firstPass(curr.right, level + 1)
+
+        def secondPass(curr: Optional[TreeNode], level: int) -> None :
+            if curr.left :
+                secondPass(curr.left, level + 1)
+
+            if level % 2 :
+                curr.val = vals.pop()
+
+            if curr.left :
+                secondPass(curr.right, level + 1)
+
+
+        firstPass(root, 0)
+        secondPass(root, 0)
+
+        return root