Added tasks 226-1143

Author: javadev

README.md

@@ -0,0 +1,62 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Dart/LeetCode-in-Dart?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Dart/LeetCode-in-Dart)
+[![](https://img.shields.io/github/forks/LeetCode-in-Dart/LeetCode-in-Dart?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Dart/LeetCode-in-Dart/fork)
+
+## 226\. Invert Binary Tree
+
+Easy
+
+Given the `root` of a binary tree, invert the tree, and return _its root_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/14/invert1-tree.jpg)
+
+**Input:** root = [4,2,7,1,3,6,9]
+
+**Output:** [4,7,2,9,6,3,1]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/03/14/invert2-tree.jpg)
+
+**Input:** root = [2,1,3]
+
+**Output:** [2,3,1]
+
+**Example 3:**
+
+**Input:** root = []
+
+**Output:** []
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 100]`.
+*   `-100 <= Node.val <= 100`
+
+## Solution
+
+```dart
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *   int val;
+ *   TreeNode? left;
+ *   TreeNode? right;
+ *   TreeNode([this.val = 0, this.left, this.right]);
+ * }
+ */
+class Solution {
+  TreeNode? invertTree(TreeNode? root) {
+    if (root == null) {
+      return root;
+    }
+    invertTree(root.left);
+    invertTree(root.right);
+    TreeNode? temp = root.left;
+    root.left = root.right;
+    root.right = temp;
+    return root;
+  }
+}
+```

src/main/dart/g0201_0300/s0226_invert_binary_tree/readme.md

@@ -0,0 +1,75 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Dart/LeetCode-in-Dart?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Dart/LeetCode-in-Dart)
+[![](https://img.shields.io/github/forks/LeetCode-in-Dart/LeetCode-in-Dart?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Dart/LeetCode-in-Dart/fork)
+
+## 230\. Kth Smallest Element in a BST
+
+Medium
+
+Given the `root` of a binary search tree, and an integer `k`, return _the_ <code>k<sup>th</sup></code> _smallest value (**1-indexed**) of all the values of the nodes in the tree_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/28/kthtree1.jpg)
+
+**Input:** root = [3,1,4,null,2], k = 1
+
+**Output:** 1
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/01/28/kthtree2.jpg)
+
+**Input:** root = [5,3,6,2,4,null,null,1], k = 3
+
+**Output:** 3
+
+**Constraints:**
+
+*   The number of nodes in the tree is `n`.
+*   <code>1 <= k <= n <= 10<sup>4</sup></code>
+*   <code>0 <= Node.val <= 10<sup>4</sup></code>
+
+**Follow up:** If the BST is modified often (i.e., we can do insert and delete operations) and you need to find the kth smallest frequently, how would you optimize?
+
+## Solution
+
+```dart
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *   int val;
+ *   TreeNode? left;
+ *   TreeNode? right;
+ *   TreeNode([this.val = 0, this.left, this.right]);
+ * }
+ */
+class Solution {
+  late int k;
+  int count = 0;
+  int? val;
+
+  int kthSmallest(TreeNode? root, int k) {
+    this.k = k;
+    _calculate(root);
+    return val!;
+  }
+
+  void _calculate(TreeNode? node) {
+    if (node == null) return;
+
+    if (node.left != null) {
+      _calculate(node.left);
+    }
+
+    count++;
+    if (count == k) {
+      val = node.val;
+      return;
+    }
+
+    if (node.right != null) {
+      _calculate(node.right);
+    }
+  }
+}
+```

src/main/dart/g0201_0300/s0230_kth_smallest_element_in_a_bst/readme.md

@@ -0,0 +1,60 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Dart/LeetCode-in-Dart?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Dart/LeetCode-in-Dart)
+[![](https://img.shields.io/github/forks/LeetCode-in-Dart/LeetCode-in-Dart?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Dart/LeetCode-in-Dart/fork)
+
+## 234\. Palindrome Linked List
+
+Easy
+
+Given the `head` of a singly linked list, return `true` _if it is a palindrome or_ `false` _otherwise_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg)
+
+**Input:** head = [1,2,2,1]
+
+**Output:** true
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg)
+
+**Input:** head = [1,2]
+
+**Output:** false
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.
+*   `0 <= Node.val <= 9`
+
+**Follow up:** Could you do it in `O(n)` time and `O(1)` space?
+
+## Solution
+
+```dart
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *   int val;
+ *   ListNode? next;
+ *   ListNode([this.val = 0, this.next]);
+ * }
+ */
+class Solution {
+  bool isPalindrome(ListNode? head) {
+    List<int> list = [];
+    while (head != null) {
+      list.add(head.val);
+      head = head.next;
+    }
+    int l = 0;
+    int r = list.length - 1;
+    while (l < list.length && r >= 0 && list[l] == list[r]) {
+      l++;
+      r--;
+    }
+    return l == list.length;
+  }
+}
+```

src/main/dart/g0201_0300/s0234_palindrome_linked_list/readme.md

@@ -0,0 +1,65 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Dart/LeetCode-in-Dart?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Dart/LeetCode-in-Dart)
+[![](https://img.shields.io/github/forks/LeetCode-in-Dart/LeetCode-in-Dart?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Dart/LeetCode-in-Dart/fork)
+
+## 238\. Product of Array Except Self
+
+Medium
+
+Given an integer array `nums`, return _an array_ `answer` _such that_ `answer[i]` _is equal to the product of all the elements of_ `nums` _except_ `nums[i]`.
+
+The product of any prefix or suffix of `nums` is **guaranteed** to fit in a **32-bit** integer.
+
+You must write an algorithm that runs in `O(n)` time and without using the division operation.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4]
+
+**Output:** [24,12,8,6]
+
+**Example 2:**
+
+**Input:** nums = [-1,1,0,-3,3]
+
+**Output:** [0,0,9,0,0]
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>5</sup></code>
+*   `-30 <= nums[i] <= 30`
+*   The product of any prefix or suffix of `nums` is **guaranteed** to fit in a **32-bit** integer.
+
+**Follow up:** Can you solve the problem in `O(1) `extra space complexity? (The output array **does not** count as extra space for space complexity analysis.)
+
+## Solution
+
+```dart
+class Solution {
+  List<int> productExceptSelf(List<int> nums) {
+    int product = 1;
+    List<int> ans = List.filled(nums.length, 0);
+
+    // Calculate total product of all elements
+    for (int num in nums) {
+      product *= num;
+    }
+
+    // Fill in the result array
+    for (int i = 0; i < nums.length; i++) {
+      if (nums[i] != 0) {
+        ans[i] = product ~/ nums[i]; // Integer division
+      } else {
+        int p = 1;
+        for (int j = 0; j < nums.length; j++) {
+          if (j != i) {
+            p *= nums[j];
+          }
+        }
+        ans[i] = p;
+      }
+    }
+
+    return ans;
+  }
+}
+```

src/main/dart/g0201_0300/s0238_product_of_array_except_self/readme.md

@@ -0,0 +1,92 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Dart/LeetCode-in-Dart?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Dart/LeetCode-in-Dart)
+[![](https://img.shields.io/github/forks/LeetCode-in-Dart/LeetCode-in-Dart?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Dart/LeetCode-in-Dart/fork)
+
+## 239\. Sliding Window Maximum
+
+Hard
+
+You are given an array of integers `nums`, there is a sliding window of size `k` which is moving from the very left of the array to the very right. You can only see the `k` numbers in the window. Each time the sliding window moves right by one position.
+
+Return _the max sliding window_.
+
+**Example 1:**
+
+**Input:** nums = [1,3,-1,-3,5,3,6,7], k = 3
+
+**Output:** [3,3,5,5,6,7]
+
+**Explanation:** 
+
+Window position Max 
+
+--------------- ----- 
+
+[1 3 -1] -3 5 3 6 7 **3** 
+
+1 [3 -1 -3] 5 3 6 7 **3** 
+
+1 3 [-1 -3 5] 3 6 7 **5** 
+
+1 3 -1 [-3 5 3] 6 7 **5** 
+
+1 3 -1 -3 [5 3 6] 7 **6** 
+
+1 3 -1 -3 5 [3 6 7] **7**
+
+**Example 2:**
+
+**Input:** nums = [1], k = 1
+
+**Output:** [1]
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+*   `1 <= k <= nums.length`
+
+## Solution
+
+```dart
+import 'dart:collection';
+
+class Solution {
+  List<int> maxSlidingWindow(List<int> nums, int k) {
+    int n = nums.length;
+    List<int> res = List.filled(n - k + 1, 0);
+    int x = 0;
+    Queue<int> dq = Queue();
+    int i = 0;
+    int j = 0;
+
+    while (j < nums.length) {
+      // Remove elements from the deque that are smaller than the current element
+      while (dq.isNotEmpty && dq.last < nums[j]) {
+        dq.removeLast();
+      }
+
+      // Add the current element to the deque
+      dq.addLast(nums[j]);
+
+      // When the window size reaches k
+      if (j - i + 1 == k) {
+        // The element at the front of the deque is the largest in the current window
+        res[x] = dq.first;
+        x++;
+
+        // If the element at the front of the deque is going out of the window, remove it
+        if (dq.first == nums[i]) {
+          dq.removeFirst();
+        }
+
+        // Slide the window to the right
+        i++;
+      }
+
+      j++;
+    }
+
+    return res;
+  }
+}
+```