leetcode

Author: ayoubzulfiqar

Diff for: README.md

@@ -160,6 +160,7 @@ This repo contain leetcode solution using DART and GO programming language. Most
 - [**2256.** Minimum Average Difference](MinimumAverageDifference/minimum_average_difference.dart)
 - [**876.** Middle of the Linked List](MiddleOfTheLinkedList/middle_of_the_linked_list.dart)
 - [**328.** Odd Even Linked List](OddEvenLinkedList/odd_even_linked_list.dart)
+- [**938.** Range Sum of BST](RangeSumOfBST/range_sum_of_bst.dart)
 
 ## Reach me via
 

Diff for: RangeSumOfBST/range_sum_of_bst.dart

@@ -0,0 +1,87 @@
+/*
+
+
+-* 938. Range Sum of BST *-
+
+
+Given the root node of a binary search tree and two integers low and high, return the sum of values of all nodes with a value in the inclusive range [low, high].
+
+ 
+
+Example 1:
+
+
+Input: root = [10,5,15,3,7,null,18], low = 7, high = 15
+Output: 32
+Explanation: Nodes 7, 10, and 15 are in the range [7, 15]. 7 + 10 + 15 = 32.
+Example 2:
+
+
+Input: root = [10,5,15,3,7,13,18,1,null,6], low = 6, high = 10
+Output: 23
+Explanation: Nodes 6, 7, and 10 are in the range [6, 10]. 6 + 7 + 10 = 23.
+ 
+
+Constraints:
+
+The number of nodes in the tree is in the range [1, 2 * 104].
+1 <= Node.val <= 105
+1 <= low <= high <= 105
+All Node.val are unique.
+
+
+*/
+
+// Definition for a binary tree node.
+class TreeNode {
+  int val;
+  TreeNode? left;
+  TreeNode? right;
+  TreeNode([this.val = 0, this.left, this.right]);
+}
+
+class A {
+  int rangeSumBST(TreeNode? root, int low, int high) {
+    if (root == null) return 0; // base case.
+    if (root.val < low)
+      return rangeSumBST(root.right, low, high); // left branch excluded.
+    if (root.val > high)
+      return rangeSumBST(root.left, low, high); // right branch excluded.
+    return root.val +
+        rangeSumBST(root.right, low, high) +
+        rangeSumBST(root.left, low, high); // count in both children.
+  }
+}
+
+class B {
+  int rangeSumBST(TreeNode? root, int low, int high) {
+    if (root == null) return 0; // base case.
+    return (low <= root.val && root.val <= high ? root.val : 0) +
+        rangeSumBST(root.right, low, high) +
+        rangeSumBST(root.left, low, high);
+  }
+}
+
+class C {
+  int rangeSumBST(TreeNode? root, int low, int high) {
+    List<TreeNode?> stk = [];
+    stk.add(root);
+    int sum = 0;
+    while (stk.isNotEmpty) {
+      TreeNode? n = stk.removeLast();
+      if (n == null) {
+        continue;
+      }
+      if (n.val > low) {
+        stk.add(n.left);
+      } // left child is a possible candidate.
+      if (n.val < high) {
+        stk.add(n.right);
+      } // right child is a possible candidate.
+      if (low <= n.val && n.val <= high) {
+        sum += n.val;
+      }
+    }
+    return sum;
+  }
+}

Diff for: RangeSumOfBST/range_sum_of_bst.go

@@ -0,0 +1,69 @@
+package main
+
+// Definition for a binary tree node.
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+// func rangeSumBST(root *TreeNode, low int, high int) int {
+// 	if root == nil {
+// 		return 0
+// 	}
+// 	if root.Val < low {
+// 		return rangeSumBST(root.Right, low, high)
+// 	}
+// 	if root.Val > high {
+// 		return rangeSumBST(root.Left, low, high)
+// 	}
+// 	return root.Val + rangeSumBST(root.Right, low, high) + rangeSumBST(root.Left, low, high)
+// }
+
+func rangeSumBST(root *TreeNode, low int, high int) int {
+	var stack []TreeNode
+	stack = append(stack, *root)
+	var sum int = 0
+	for len(stack) != 0 {
+		var node *TreeNode = &stack[len(stack)-1]
+		if node == nil {
+			continue
+		}
+		if node.Val > low {
+			stack = append(stack, *node.Left)
+		}
+		if node.Val < high {
+			stack = append(stack, *node.Right)
+		}
+		if low <= node.Val && node.Val <= high {
+			sum += node.Val
+		}
+	}
+	return sum
+}
+
+/*
+
+ int rangeSumBST(TreeNode? root, int low, int high) {
+    List<TreeNode?> stk = [];
+    stk.add(root);
+    int sum = 0;
+    while (stk.isNotEmpty) {
+      TreeNode? n = stk.removeLast();
+      if (n == null) {
+        continue;
+      }
+      if (n.val > low) {
+        stk.add(n.left);
+      } // left child is a possible candidate.
+      if (n.val < high) {
+        stk.add(n.right);
+      } // right child is a possible candidate.
+      if (low <= n.val && n.val <= high) {
+        sum += n.val;
+      }
+    }
+    return sum;
+  }
+
+*/

Diff for: RangeSumOfBST/range_sum_of_bst.md

@@ -0,0 +1,70 @@
+# 🔥 Range Sum of BST 🔥 || Simple Fast and Easy || with Explanation
+
+## Definition for a binary tree node
+
+```dart
+class TreeNode {
+  int val;
+  TreeNode? left;
+  TreeNode? right;
+  TreeNode([this.val = 0, this.left, this.right]);
+}
+```
+
+## Solution - 1
+
+```dart
+class Solution {
+  int rangeSumBST(TreeNode? root, int low, int high) {
+    if (root == null) return 0; // base case.
+    if (root.val < low)
+      return rangeSumBST(root.right, low, high); // left branch excluded.
+    if (root.val > high)
+      return rangeSumBST(root.left, low, high); // right branch excluded.
+    return root.val +
+        rangeSumBST(root.right, low, high) +
+        rangeSumBST(root.left, low, high); // count in both children.
+  }
+}
+```
+
+## Solution - 2
+
+```dart
+class Solution {
+  int rangeSumBST(TreeNode? root, int low, int high) {
+    if (root == null) return 0; // base case.
+    return (low <= root.val && root.val <= high ? root.val : 0) +
+        rangeSumBST(root.right, low, high) +
+        rangeSumBST(root.left, low, high);
+  }
+}
+```
+
+## Solution - 3
+
+```dart
+class Solution {
+  int rangeSumBST(TreeNode? root, int low, int high) {
+    List<TreeNode?> stk = [];
+    stk.add(root);
+    int sum = 0;
+    while (stk.isNotEmpty) {
+      TreeNode? n = stk.removeLast();
+      if (n == null) {
+        continue;
+      }
+      if (n.val > low) {
+        stk.add(n.left);
+      } // left child is a possible candidate.
+      if (n.val < high) {
+        stk.add(n.right);
+      } // right child is a possible candidate.
+      if (low <= n.val && n.val <= high) {
+        sum += n.val;
+      }
+    }
+    return sum;
+  }
+}
+```