Added tasks 148-239

Author: javadev

README.md

@@ -0,0 +1,105 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 148\. Sort List
+
+Medium
+
+Given the `head` of a linked list, return _the list after sorting it in **ascending order**_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/14/sort_list_1.jpg)
+
+**Input:** head = [4,2,1,3]
+
+**Output:** [1,2,3,4]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/09/14/sort_list_2.jpg)
+
+**Input:** head = [-1,5,3,4,0]
+
+**Output:** [-1,0,3,4,5]
+
+**Example 3:**
+
+**Input:** head = []
+
+**Output:** []
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range <code>[0, 5 * 10<sup>4</sup>]</code>.
+*   <code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code>
+
+**Follow up:** Can you sort the linked list in `O(n logn)` time and `O(1)` memory (i.e. constant space)?
+
+## Solution
+
+```c
+#include <stdio.h>
+#include <stdlib.h>
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     struct ListNode *next;
+ * };
+ */
+// Helper function to create a new ListNode
+struct ListNode* createNode(int val) {
+    struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
+    node->val = val;
+    node->next = NULL;
+    return node;
+}
+
+// Helper function to merge two sorted linked lists
+struct ListNode* merge(struct ListNode* l1, struct ListNode* l2) {
+    struct ListNode dummy;
+    struct ListNode* tail = &dummy;
+    dummy.next = NULL;
+
+    while (l1 != NULL && l2 != NULL) {
+        if (l1->val <= l2->val) {
+            tail->next = l1;
+            l1 = l1->next;
+        } else {
+            tail->next = l2;
+            l2 = l2->next;
+        }
+        tail = tail->next;
+    }
+
+    if (l1 != NULL) tail->next = l1;
+    if (l2 != NULL) tail->next = l2;
+
+    return dummy.next;
+}
+
+// Function to sort the linked list using merge sort
+struct ListNode* sortList(struct ListNode* head) {
+    if (head == NULL || head->next == NULL) {
+        return head;
+    }
+
+    // Split the list into two halves
+    struct ListNode *slow = head, *fast = head, *pre = NULL;
+    while (fast != NULL && fast->next != NULL) {
+        pre = slow;
+        slow = slow->next;
+        fast = fast->next->next;
+    }
+    pre->next = NULL; // Break the list into two halves
+
+    // Recursively sort both halves
+    struct ListNode* left = sortList(head);
+    struct ListNode* right = sortList(slow);
+
+    // Merge the sorted halves
+    return merge(left, right);
+}
+```

src/main/c/g0101_0200/s0148_sort_list/readme.md

@@ -0,0 +1,78 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 152\. Maximum Product Subarray
+
+Medium
+
+Given an integer array `nums`, find a contiguous non-empty subarray within the array that has the largest product, and return _the product_.
+
+The test cases are generated so that the answer will fit in a **32-bit** integer.
+
+A **subarray** is a contiguous subsequence of the array.
+
+**Example 1:**
+
+**Input:** nums = [2,3,-2,4]
+
+**Output:** 6
+
+**Explanation:** [2,3] has the largest product 6.
+
+**Example 2:**
+
+**Input:** nums = [-2,0,-1]
+
+**Output:** 0
+
+**Explanation:** The result cannot be 2, because [-2,-1] is not a subarray.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 2 * 10<sup>4</sup></code>
+*   `-10 <= nums[i] <= 10`
+*   The product of any prefix or suffix of `nums` is **guaranteed** to fit in a **32-bit** integer.
+
+## Solution
+
+```c
+#include <stdio.h>
+#include <limits.h>
+
+// Function to get the maximum of two integers
+int max(int a, int b) {
+    return (a > b) ? a : b;
+}
+
+// Function to get the minimum of two integers
+int min(int a, int b) {
+    return (a < b) ? a : b;
+}
+
+// Function to find the maximum product subarray
+int maxProduct(int* nums, int numsSize) {
+    if (numsSize == 0) return 0;
+
+    int currentMaxProd = nums[0];
+    int currentMinProd = nums[0];
+    int overAllMaxProd = nums[0];
+
+    for (int i = 1; i < numsSize; i++) {
+        if (nums[i] < 0) {
+            // Swap currentMaxProd and currentMinProd
+            int temp = currentMaxProd;
+            currentMaxProd = currentMinProd;
+            currentMinProd = temp;
+        }
+
+        // Update the current maximum and minimum products
+        currentMaxProd = max(nums[i], nums[i] * currentMaxProd);
+        currentMinProd = min(nums[i], nums[i] * currentMinProd);
+
+        // Update the overall maximum product
+        overAllMaxProd = max(overAllMaxProd, currentMaxProd);
+    }
+
+    return overAllMaxProd;
+}
+```

src/main/c/g0101_0200/s0152_maximum_product_subarray/readme.md

@@ -0,0 +1,91 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 153\. Find Minimum in Rotated Sorted Array
+
+Medium
+
+Suppose an array of length `n` sorted in ascending order is **rotated** between `1` and `n` times. For example, the array `nums = [0,1,2,4,5,6,7]` might become:
+
+*   `[4,5,6,7,0,1,2]` if it was rotated `4` times.
+*   `[0,1,2,4,5,6,7]` if it was rotated `7` times.
+
+Notice that **rotating** an array `[a[0], a[1], a[2], ..., a[n-1]]` 1 time results in the array `[a[n-1], a[0], a[1], a[2], ..., a[n-2]]`.
+
+Given the sorted rotated array `nums` of **unique** elements, return _the minimum element of this array_.
+
+You must write an algorithm that runs in `O(log n) time.`
+
+**Example 1:**
+
+**Input:** nums = [3,4,5,1,2]
+
+**Output:** 1
+
+**Explanation:** The original array was [1,2,3,4,5] rotated 3 times.
+
+**Example 2:**
+
+**Input:** nums = [4,5,6,7,0,1,2]
+
+**Output:** 0
+
+**Explanation:** The original array was [0,1,2,4,5,6,7] and it was rotated 4 times.
+
+**Example 3:**
+
+**Input:** nums = [11,13,15,17]
+
+**Output:** 11
+
+**Explanation:** The original array was [11,13,15,17] and it was rotated 4 times.
+
+**Constraints:**
+
+*   `n == nums.length`
+*   `1 <= n <= 5000`
+*   `-5000 <= nums[i] <= 5000`
+*   All the integers of `nums` are **unique**.
+*   `nums` is sorted and rotated between `1` and `n` times.
+
+## Solution
+
+```c
+#include <stdio.h>
+
+// Helper function to find the minimum element in a rotated sorted array
+int findMinUtil(int* nums, int l, int r) {
+    if (l == r) {
+        return nums[l];
+    }
+
+    int mid = (l + r) / 2;
+
+    // If array is not rotated or only two elements left
+    if (mid == l && nums[mid] < nums[r]) {
+        return nums[l];
+    }
+
+    // Check if the middle element is the minimum
+    if (mid - 1 >= 0 && nums[mid - 1] > nums[mid]) {
+        return nums[mid];
+    }
+
+    // Decide which half to search
+    if (nums[mid] < nums[l]) {
+        return findMinUtil(nums, l, mid - 1);
+    } else if (nums[mid] > nums[r]) {
+        return findMinUtil(nums, mid + 1, r);
+    }
+
+    // If there’s ambiguity, search the left half
+    return findMinUtil(nums, l, mid - 1);
+}
+
+// Function to initialize the search for minimum in the rotated sorted array
+int findMin(int* nums, int numsSize) {
+    int l = 0;
+    int r = numsSize - 1;
+    return findMinUtil(nums, l, r);
+}
+```

src/main/c/g0101_0200/s0153_find_minimum_in_rotated_sorted_array/readme.md

@@ -0,0 +1,142 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 155\. Min Stack
+
+Easy
+
+Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.
+
+Implement the `MinStack` class:
+
+*   `MinStack()` initializes the stack object.
+*   `void push(int val)` pushes the element `val` onto the stack.
+*   `void pop()` removes the element on the top of the stack.
+*   `int top()` gets the top element of the stack.
+*   `int getMin()` retrieves the minimum element in the stack.
+
+**Example 1:**
+
+**Input**
+
+    ["MinStack","push","push","push","getMin","pop","top","getMin"]
+    [[],[-2],[0],[-3],[],[],[],[]]
+
+**Output:** [null,null,null,null,-3,null,0,-2]
+
+**Explanation:**
+
+    MinStack minStack = new MinStack();
+    minStack.push(-2);
+    minStack.push(0);
+    minStack.push(-3);
+    minStack.getMin(); // return -3
+    minStack.pop();
+    minStack.top(); // return 0
+    minStack.getMin(); // return -2 
+
+**Constraints:**
+
+*   <code>-2<sup>31</sup> <= val <= 2<sup>31</sup> - 1</code>
+*   Methods `pop`, `top` and `getMin` operations will always be called on **non-empty** stacks.
+*   At most <code>3 * 10<sup>4</sup></code> calls will be made to `push`, `pop`, `top`, and `getMin`.
+
+## Solution
+
+```c
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+// Define the structure for a node in the stack
+typedef struct Node {
+    int min;
+    int data;
+    struct Node* nextNode;
+    struct Node* previousNode;
+} Node;
+
+// Define the structure for MinStack
+typedef struct {
+    Node* currentNode;
+} MinStack;
+
+// Function to create a new node
+Node* createNode(int min, int data, Node* previousNode, Node* nextNode) {
+    Node* node = (Node*)malloc(sizeof(Node));
+    node->min = min;
+    node->data = data;
+    node->previousNode = previousNode;
+    node->nextNode = nextNode;
+    return node;
+}
+
+// Initialize MinStack
+MinStack* minStackCreate() {
+    MinStack* stack = (MinStack*)malloc(sizeof(MinStack));
+    stack->currentNode = NULL;
+    return stack;
+}
+
+// Push a value onto the MinStack
+void minStackPush(MinStack* obj, int val) {
+    if (obj->currentNode == NULL) {
+        obj->currentNode = createNode(val, val, NULL, NULL);
+    } else {
+        obj->currentNode->nextNode = createNode(
+            (val < obj->currentNode->min) ? val : obj->currentNode->min, 
+            val, 
+            obj->currentNode, 
+            NULL
+        );
+        obj->currentNode = obj->currentNode->nextNode;
+    }
+}
+
+// Pop the top element from the MinStack
+void minStackPop(MinStack* obj) {
+    if (obj->currentNode != NULL) {
+        Node* temp = obj->currentNode;
+        obj->currentNode = obj->currentNode->previousNode;
+        free(temp);
+    }
+}
+
+// Get the top element of the MinStack
+int minStackTop(MinStack* obj) {
+    if (obj->currentNode != NULL) {
+        return obj->currentNode->data;
+    }
+    return INT_MIN; // Or an error code if stack is empty
+}
+
+// Get the minimum element in the MinStack
+int minStackGetMin(MinStack* obj) {
+    if (obj->currentNode != NULL) {
+        return obj->currentNode->min;
+    }
+    return INT_MIN; // Or an error code if stack is empty
+}
+
+// Free the MinStack
+void minStackFree(MinStack* obj) {
+    while (obj->currentNode != NULL) {
+        minStackPop(obj);
+    }
+    free(obj);
+}
+
+/**
+ * Your MinStack struct will be instantiated and called as such:
+ * MinStack* obj = minStackCreate();
+ * minStackPush(obj, val);
+ 
+ * minStackPop(obj);
+ 
+ * int param_3 = minStackTop(obj);
+ 
+ * int param_4 = minStackGetMin(obj);
+ 
+ * minStackFree(obj);
+*/
+```

src/main/c/g0101_0200/s0155_min_stack/readme.md

@@ -0,0 +1,106 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 160\. Intersection of Two Linked Lists
+
+Easy
+
+Given the heads of two singly linked-lists `headA` and `headB`, return _the node at which the two lists intersect_. If the two linked lists have no intersection at all, return `null`.
+
+For example, the following two linked lists begin to intersect at node `c1`:
+
+![](https://assets.leetcode.com/uploads/2021/03/05/160_statement.png)
+
+The test cases are generated such that there are no cycles anywhere in the entire linked structure.
+
+**Note** that the linked lists must **retain their original structure** after the function returns.
+
+**Custom Judge:**
+
+The inputs to the **judge** are given as follows (your program is **not** given these inputs):
+
+*   `intersectVal` - The value of the node where the intersection occurs. This is `0` if there is no intersected node.
+*   `listA` - The first linked list.
+*   `listB` - The second linked list.
+*   `skipA` - The number of nodes to skip ahead in `listA` (starting from the head) to get to the intersected node.
+*   `skipB` - The number of nodes to skip ahead in `listB` (starting from the head) to get to the intersected node.
+
+The judge will then create the linked structure based on these inputs and pass the two heads, `headA` and `headB` to your program. If you correctly return the intersected node, then your solution will be **accepted**.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/05/160_example_1_1.png)
+
+**Input:** intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
+
+**Output:** Intersected at '8'
+
+**Explanation:** The intersected node's value is 8 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,6,1,8,4,5]. There are 2 nodes before the intersected node in A; There are 3 nodes before the intersected node in B. 
+
+- Note that the intersected node's value is not 1 because the nodes with value 1 in A and B (2<sup>nd</sup> node in A and 3<sup>rd</sup> node in B) are different node references. In other words, they point to two different locations in memory, while the nodes with value 8 in A and B (3<sup>rd</sup> node in A and 4<sup>th</sup> node in B) point to the same location in memory.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/03/05/160_example_2.png)
+
+**Input:** intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
+
+**Output:** Intersected at '2'
+
+**Explanation:** The intersected node's value is 2 (note that this must not be 0 if the two lists intersect).
+
+From the head of A, it reads as [1,9,1,2,4]. From the head of B, it reads as [3,2,4]. There are 3 nodes before the intersected node in A; There are 1 node before the intersected node in B.
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/03/05/160_example_3.png)
+
+**Input:** intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
+
+**Output:** No intersection
+
+**Explanation:** From the head of A, it reads as [2,6,4]. From the head of B, it reads as [1,5]. Since the two lists do not intersect, intersectVal must be 0, while skipA and skipB can be arbitrary values. Explanation: The two lists do not intersect, so return null.
+
+**Constraints:**
+
+*   The number of nodes of `listA` is in the `m`.
+*   The number of nodes of `listB` is in the `n`.
+*   <code>1 <= m, n <= 3 * 10<sup>4</sup></code>
+*   <code>1 <= Node.val <= 10<sup>5</sup></code>
+*   `0 <= skipA < m`
+*   `0 <= skipB < n`
+*   `intersectVal` is `0` if `listA` and `listB` do not intersect.
+*   `intersectVal == listA[skipA] == listB[skipB]` if `listA` and `listB` intersect.
+
+**Follow up:** Could you write a solution that runs in `O(m + n)` time and use only `O(1)` memory?
+
+## Solution
+
+```c
+#include <stdio.h>
+#include <stdlib.h>
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     struct ListNode *next;
+ * };
+ */
+// Function to find the intersection node of two linked lists
+struct ListNode* getIntersectionNode(struct ListNode* headA, struct ListNode* headB) {
+    struct ListNode* node1 = headA;
+    struct ListNode* node2 = headB;
+    
+    // Loop until the two pointers meet at the intersection or both become NULL
+    while (node1 != node2) {
+        // If node1 reaches the end of list A, switch to the head of list B
+        node1 = (node1 == NULL) ? headB : node1->next;
+        // If node2 reaches the end of list B, switch to the head of list A
+        node2 = (node2 == NULL) ? headA : node2->next;
+    }
+    
+    // Both pointers will either meet at the intersection node or at NULL if no intersection exists
+    return node1;
+}
+```

src/main/c/g0101_0200/s0160_intersection_of_two_linked_lists/readme.md

@@ -0,0 +1,71 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 169\. Majority Element
+
+Easy
+
+Given an array `nums` of size `n`, return _the majority element_.
+
+The majority element is the element that appears more than `⌊n / 2⌋` times. You may assume that the majority element always exists in the array.
+
+**Example 1:**
+
+**Input:** nums = [3,2,3]
+
+**Output:** 3
+
+**Example 2:**
+
+**Input:** nums = [2,2,1,1,1,2,2]
+
+**Output:** 2
+
+**Constraints:**
+
+*   `n == nums.length`
+*   <code>1 <= n <= 5 * 10<sup>4</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+
+**Follow-up:** Could you solve the problem in linear time and in `O(1)` space?
+
+## Solution
+
+```c
+#include <stdio.h>
+
+// Function to find the majority element in an array
+int majorityElement(int* arr, int arrSize) {
+    int count = 1;
+    int majority = arr[0];
+    
+    // First pass to find a potential majority element using Boyer-Moore Voting Algorithm
+    for (int i = 1; i < arrSize; i++) {
+        if (arr[i] == majority) {
+            count++;
+        } else {
+            if (count > 1) {
+                count--;
+            } else {
+                majority = arr[i];
+                count = 1;
+            }
+        }
+    }
+
+    // Second pass to confirm if the candidate is indeed the majority element
+    count = 0;
+    for (int i = 0; i < arrSize; i++) {
+        if (arr[i] == majority) {
+            count++;
+        }
+    }
+
+    // Check if the majority element appears more than n/2 times
+    if (count >= (arrSize / 2) + 1) {
+        return majority;
+    } else {
+        return -1;
+    }
+}
+```

src/main/c/g0101_0200/s0169_majority_element/readme.md

@@ -0,0 +1,74 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 189\. Rotate Array
+
+Medium
+
+Given an array, rotate the array to the right by `k` steps, where `k` is non-negative.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4,5,6,7], k = 3
+
+**Output:** [5,6,7,1,2,3,4]
+
+**Explanation:** 
+
+rotate 1 steps to the right: [7,1,2,3,4,5,6] 
+
+rotate 2 steps to the right: [6,7,1,2,3,4,5] 
+
+rotate 3 steps to the right: [5,6,7,1,2,3,4]
+
+**Example 2:**
+
+**Input:** nums = [-1,-100,3,99], k = 2
+
+**Output:** [3,99,-1,-100]
+
+**Explanation:** 
+
+rotate 1 steps to the right: [99,-1,-100,3] 
+
+rotate 2 steps to the right: [3,99,-1,-100]
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>
+*   <code>0 <= k <= 10<sup>5</sup></code>
+
+**Follow up:**
+
+*   Try to come up with as many solutions as you can. There are at least **three** different ways to solve this problem.
+*   Could you do it in-place with `O(1)` extra space?
+
+## Solution
+
+```c
+#include <stdio.h>
+
+// Helper function to reverse a subarray in place
+void reverse(int* nums, int l, int r) {
+    while (l < r) {
+        int temp = nums[l];
+        nums[l] = nums[r];
+        nums[r] = temp;
+        l++;
+        r--;
+    }
+}
+
+// Function to rotate the array to the right by k steps
+void rotate(int* nums, int numsSize, int k) {
+    int n = numsSize;
+    k = k % n;  // Handle cases where k is greater than n
+    int t = n - k;
+    
+    // Reverse different parts of the array in three steps
+    reverse(nums, 0, t - 1);   // Reverse the first part (0 to t - 1)
+    reverse(nums, t, n - 1);   // Reverse the second part (t to n - 1)
+    reverse(nums, 0, n - 1);   // Reverse the whole array (0 to n - 1)
+}
+```

src/main/c/g0101_0200/s0189_rotate_array/readme.md

@@ -0,0 +1,68 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 198\. House Robber
+
+Medium
+
+You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security systems connected and **it will automatically contact the police if two adjacent houses were broken into on the same night**.
+
+Given an integer array `nums` representing the amount of money of each house, return _the maximum amount of money you can rob tonight **without alerting the police**_.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,1]
+
+**Output:** 4
+
+**Explanation:** Rob house 1 (money = 1) and then rob house 3 (money = 3). Total amount you can rob = 1 + 3 = 4.
+
+**Example 2:**
+
+**Input:** nums = [2,7,9,3,1]
+
+**Output:** 12
+
+**Explanation:** Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1). Total amount you can rob = 2 + 9 + 1 = 12.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `0 <= nums[i] <= 400`
+
+## Solution
+
+```c
+#include <stdio.h>
+
+// Helper function to find the maximum of two integers
+int max(int a, int b) {
+    return (a > b) ? a : b;
+}
+
+// Function to calculate the maximum profit from robbing houses
+int rob(int* nums, int numsSize) {
+    if (numsSize == 0) {
+        return 0;
+    }
+    if (numsSize == 1) {
+        return nums[0];
+    }
+    if (numsSize == 2) {
+        return max(nums[0], nums[1]);
+    }
+
+    // Array to store the maximum profit up to each house
+    int profit[numsSize];
+    profit[0] = nums[0];
+    profit[1] = max(nums[1], nums[0]);
+
+    // Fill in the profit array using dynamic programming
+    for (int i = 2; i < numsSize; i++) {
+        profit[i] = max(profit[i - 1], nums[i] + profit[i - 2]);
+    }
+
+    // The last element in the profit array contains the maximum profit
+    return profit[numsSize - 1];
+}
+```

src/main/c/g0101_0200/s0198_house_robber/readme.md

@@ -0,0 +1,88 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 200\. Number of Islands
+
+Medium
+
+Given an `m x n` 2D binary grid `grid` which represents a map of `'1'`s (land) and `'0'`s (water), return _the number of islands_.
+
+An **island** is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.
+
+**Example 1:**
+
+**Input:** grid = [ 
+
+["1","1","1","1","0"], 
+
+["1","1","0","1","0"], 
+
+["1","1","0","0","0"], 
+
+["0","0","0","0","0"] 
+
+]
+
+**Output:** 1
+
+**Example 2:**
+
+**Input:** grid = [ 
+
+["1","1","0","0","0"], 
+
+["1","1","0","0","0"], 
+
+["0","0","1","0","0"], 
+
+["0","0","0","1","1"] 
+
+]
+
+**Output:** 3
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 300`
+*   `grid[i][j]` is `'0'` or `'1'`.
+
+## Solution
+
+```c
+void DFS(int row, int col, int m, int n, char** grid) {
+    if (row < 0 || row >= m || col < 0 || col >= n || grid[row][col] == '0') {
+        return;
+    }
+
+    grid[row][col] = '0'; // Mark the current cell as visited
+
+    // Visit the neighboring cells
+    DFS(row + 1, col, m, n, grid);
+    DFS(row - 1, col, m, n, grid);
+    DFS(row, col + 1, m, n, grid);
+    DFS(row, col - 1, m, n, grid);
+}
+
+int numIslands(char** grid, int gridSize, int* gridColSize) {
+    if (gridSize == 0) {
+        return 0;
+    }
+
+    int m = gridSize;  // ROW
+    int n = *gridColSize; // COL
+    int numIslands = 0;
+
+    for (int i = 0; i < m; i++) {
+        for (int j = 0; j < n; j++) {
+            if (grid[i][j] == '1') {  // grid[row][col]
+                numIslands++;
+                DFS(i, j, m, n, grid);
+            }
+        }
+    }
+
+    return numIslands;
+}
+```

src/main/c/g0101_0200/s0200_number_of_islands/readme.md

@@ -0,0 +1,66 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 206\. Reverse Linked List
+
+Easy
+
+Given the `head` of a singly linked list, reverse the list, and return _the reversed list_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/rev1ex1.jpg)
+
+**Input:** head = [1,2,3,4,5]
+
+**Output:** [5,4,3,2,1]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/rev1ex2.jpg)
+
+**Input:** head = [1,2]
+
+**Output:** [2,1]
+
+**Example 3:**
+
+**Input:** head = []
+
+**Output:** []
+
+**Constraints:**
+
+*   The number of nodes in the list is the range `[0, 5000]`.
+*   `-5000 <= Node.val <= 5000`
+
+**Follow up:** A linked list can be reversed either iteratively or recursively. Could you implement both?
+
+## Solution
+
+```c
+#include <stdio.h>
+#include <stdlib.h>
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     struct ListNode *next;
+ * };
+ */
+// Function to reverse a linked list
+struct ListNode* reverseList(struct ListNode* head) {
+    struct ListNode* prev = NULL;   // Pointer to the previous node
+    struct ListNode* curr = head;    // Pointer to the current node
+    
+    while (curr != NULL) {
+        struct ListNode* next = curr->next; // Store the next node
+        curr->next = prev;                  // Reverse the current node's pointer
+        prev = curr;                        // Move prev to the current node
+        curr = next;                        // Move to the next node
+    }
+    
+    return prev; // New head of the reversed list
+}
+```

src/main/c/g0201_0300/s0206_reverse_linked_list/readme.md

@@ -0,0 +1,90 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 207\. Course Schedule
+
+Medium
+
+There are a total of `numCourses` courses you have to take, labeled from `0` to `numCourses - 1`. You are given an array `prerequisites` where <code>prerequisites[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that you **must** take course <code>b<sub>i</sub></code> first if you want to take course <code>a<sub>i</sub></code>.
+
+*   For example, the pair `[0, 1]`, indicates that to take course `0` you have to first take course `1`.
+
+Return `true` if you can finish all courses. Otherwise, return `false`.
+
+**Example 1:**
+
+**Input:** numCourses = 2, prerequisites = \[\[1,0]]
+
+**Output:** true
+
+**Explanation:** There are a total of 2 courses to take. To take course 1 you should have finished course 0. So it is possible.
+
+**Example 2:**
+
+**Input:** numCourses = 2, prerequisites = \[\[1,0],[0,1]]
+
+**Output:** false
+
+**Explanation:** There are a total of 2 courses to take. To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.
+
+**Constraints:**
+
+*   `1 <= numCourses <= 2000`
+*   `0 <= prerequisites.length <= 5000`
+*   `prerequisites[i].length == 2`
+*   <code>0 <= a<sub>i</sub>, b<sub>i</sub> < numCourses</code>
+*   All the pairs prerequisites[i] are **unique**.
+
+## Solution
+
+```c
+typedef struct node {
+    int V;
+    struct node* next;
+} node;
+
+bool dfs(node** adjlist, bool* visited, bool* recStack, int current);
+
+bool canFinish(int numCourses, int** prerequisites, int prerequisitesSize, int* prerequisitesColSize) {
+    node** adjlist = malloc(sizeof(node*) * numCourses);
+    for (int i = 0; i < numCourses; i++) {
+        adjlist[i] = NULL;
+    }
+    for (int i = 0; i < prerequisitesSize; i++) {
+        node* Node = malloc(sizeof(node));
+        Node->V = prerequisites[i][0];
+        Node->next = adjlist[prerequisites[i][1]];
+        adjlist[prerequisites[i][1]] = Node;
+    }
+
+    bool* visited = calloc(sizeof(bool), numCourses);
+    bool* recStack = calloc(sizeof(bool), numCourses);
+
+    for (int V = 0; V < numCourses; V++) {
+        if (dfs(adjlist, visited, recStack, V)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool dfs(node** adjlist, bool* visited, bool* recStack, int current) {
+    if (recStack[current]) {
+        return true;
+    }
+    if (visited[current]) {
+        return false;
+    }
+    visited[current] = true;
+    recStack[current] = true;
+
+    for (node* Node = adjlist[current]; Node; Node = Node->next) {
+        if (dfs(adjlist, visited, recStack, Node->V)) {
+            return true;
+        }
+    }
+
+    recStack[current] = false;
+    return false;
+}
+```

src/main/c/g0201_0300/s0207_course_schedule/readme.md

@@ -0,0 +1,142 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 208\. Implement Trie (Prefix Tree)
+
+Medium
+
+A [**trie**](https://en.wikipedia.org/wiki/Trie) (pronounced as "try") or **prefix tree** is a tree data structure used to efficiently store and retrieve keys in a dataset of strings. There are various applications of this data structure, such as autocomplete and spellchecker.
+
+Implement the Trie class:
+
+*   `Trie()` Initializes the trie object.
+*   `void insert(String word)` Inserts the string `word` into the trie.
+*   `boolean search(String word)` Returns `true` if the string `word` is in the trie (i.e., was inserted before), and `false` otherwise.
+*   `boolean startsWith(String prefix)` Returns `true` if there is a previously inserted string `word` that has the prefix `prefix`, and `false` otherwise.
+
+**Example 1:**
+
+**Input** ["Trie", "insert", "search", "search", "startsWith", "insert", "search"] [[], ["apple"], ["apple"], ["app"], ["app"], ["app"], ["app"]]
+
+**Output:** [null, null, true, false, true, null, true]
+
+**Explanation:** 
+
+Trie trie = new Trie(); 
+
+trie.insert("apple"); 
+
+trie.search("apple"); // return True 
+
+trie.search("app"); // return False 
+
+trie.startsWith("app"); // return True 
+
+trie.insert("app"); 
+
+trie.search("app"); // return True
+
+**Constraints:**
+
+*   `1 <= word.length, prefix.length <= 2000`
+*   `word` and `prefix` consist only of lowercase English letters.
+*   At most <code>3 * 10<sup>4</sup></code> calls **in total** will be made to `insert`, `search`, and `startsWith`.
+
+## Solution
+
+```c
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+
+#define ALPHABET_SIZE 26
+
+typedef struct TrieNode {
+    struct TrieNode* children[ALPHABET_SIZE];
+    bool isWord;
+} TrieNode;
+
+typedef struct Trie {
+    TrieNode* root;
+} Trie;
+
+// Helper function to create a new TrieNode
+TrieNode* createTrieNode() {
+    TrieNode* node = (TrieNode*)malloc(sizeof(TrieNode));
+    for (int i = 0; i < ALPHABET_SIZE; i++) {
+        node->children[i] = NULL;
+    }
+    node->isWord = false;
+    return node;
+}
+
+// Function to create a new Trie
+Trie* trieCreate() {
+    Trie* trie = (Trie*)malloc(sizeof(Trie));
+    trie->root = createTrieNode();
+    return trie;
+}
+
+// Function to insert a word into the Trie
+void trieInsert(Trie* obj, char* word) {
+    TrieNode* node = obj->root;
+    for (int i = 0; i < strlen(word); i++) {
+        int index = word[i] - 'a';
+        if (node->children[index] == NULL) {
+            node->children[index] = createTrieNode();
+        }
+        node = node->children[index];
+    }
+    node->isWord = true;
+}
+
+// Recursive helper function to search for a word or prefix
+bool trieSearchHelper(TrieNode* node, char* word, bool checkPrefix) {
+    for (int i = 0; i < strlen(word); i++) {
+        int index = word[i] - 'a';
+        if (node->children[index] == NULL) {
+            return false;
+        }
+        node = node->children[index];
+    }
+    return checkPrefix || node->isWord;
+}
+
+// Function to search for a complete word in the Trie
+bool trieSearch(Trie* obj, char* word) {
+    return trieSearchHelper(obj->root, word, false);
+}
+
+// Function to check if any word in the Trie starts with the given prefix
+bool trieStartsWith(Trie* obj, char* prefix) {
+    return trieSearchHelper(obj->root, prefix, true);
+}
+
+// Recursive function to free all TrieNodes
+void trieFreeNode(TrieNode* node) {
+    if (node == NULL) return;
+    for (int i = 0; i < ALPHABET_SIZE; i++) {
+        trieFreeNode(node->children[i]);
+    }
+    free(node);
+}
+
+// Function to free the entire Trie
+void trieFree(Trie* obj) {
+    trieFreeNode(obj->root);
+    free(obj);
+}
+
+/**
+ * Your Trie struct will be instantiated and called as such:
+ * Trie* obj = trieCreate();
+ * trieInsert(obj, word);
+ 
+ * bool param_2 = trieSearch(obj, word);
+ 
+ * bool param_3 = trieStartsWith(obj, prefix);
+ 
+ * trieFree(obj);
+*/
+```

src/main/c/g0201_0300/s0208_implement_trie_prefix_tree/readme.md

@@ -0,0 +1,76 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 215\. Kth Largest Element in an Array
+
+Medium
+
+Given an integer array `nums` and an integer `k`, return _the_ <code>k<sup>th</sup></code> _largest element in the array_.
+
+Note that it is the <code>k<sup>th</sup></code> largest element in the sorted order, not the <code>k<sup>th</sup></code> distinct element.
+
+You must solve it in `O(n)` time complexity.
+
+**Example 1:**
+
+**Input:** nums = [3,2,1,5,6,4], k = 2
+
+**Output:** 5
+
+**Example 2:**
+
+**Input:** nums = [3,2,3,1,2,4,5,5,6], k = 4
+
+**Output:** 4
+
+**Constraints:**
+
+*   <code>1 <= k <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+
+## Solution
+
+```c
+#include <stdbool.h>
+#include <stdlib.h>
+
+int findKthLargest(int* nums, int numsSize, int k) {
+    int positiveArr[10001] = {0};
+    int negativeArr[10001] = {0};
+    int cumulativeCount = 0;
+    int result = 0;
+    bool found = false;
+
+    // Count occurrences of each element
+    for (int i = 0; i < numsSize; i++) {
+        if (nums[i] >= 0) {
+            positiveArr[nums[i]]++;
+        } else {
+            negativeArr[abs(nums[i])]++;
+        }
+    }
+
+    // Search for the k-th largest in positive numbers
+    for (int i = 10000; i >= 0; i--) {
+        cumulativeCount += positiveArr[i];
+        if (cumulativeCount >= k) {
+            result = i;
+            found = true;
+            break;
+        }
+    }
+
+    // If k-th largest is not found in positive numbers, search in negative numbers
+    if (!found) {
+        for (int i = 1; i <= 10000; i++) {
+            cumulativeCount += negativeArr[i];
+            if (cumulativeCount >= k) {
+                result = -i;
+                break;
+            }
+        }
+    }
+
+    return result;
+}
+```

src/main/c/g0201_0300/s0215_kth_largest_element_in_an_array/readme.md

@@ -0,0 +1,89 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 221\. Maximal Square
+
+Medium
+
+Given an `m x n` binary `matrix` filled with `0`'s and `1`'s, _find the largest square containing only_ `1`'s _and return its area_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/26/max1grid.jpg)
+
+**Input:** matrix = \[\["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]
+
+**Output:** 4
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/26/max2grid.jpg)
+
+**Input:** matrix = \[\["0","1"],["1","0"]]
+
+**Output:** 1
+
+**Example 3:**
+
+**Input:** matrix = \[\["0"]]
+
+**Output:** 0
+
+**Constraints:**
+
+*   `m == matrix.length`
+*   `n == matrix[i].length`
+*   `1 <= m, n <= 300`
+*   `matrix[i][j]` is `'0'` or `'1'`.
+
+## Solution
+
+```c
+#include <stdio.h>
+#include <stdlib.h>
+
+int min(int a, int b) {
+    return a < b ? a : b;
+}
+
+int min3(int a, int b, int c) {
+    return min(a, min(b, c));
+}
+
+int maximalSquare(char** matrix, int matrixSize, int* matrixColSize) {
+    if (matrixSize == 0 || matrixColSize[0] == 0) {
+        return 0;
+    }
+    
+    int m = matrixSize;
+    int n = matrixColSize[0];
+    
+    // Create a dynamic programming (dp) array initialized to 0
+    int** dp = (int**)malloc((m + 1) * sizeof(int*));
+    for (int i = 0; i <= m; i++) {
+        dp[i] = (int*)calloc(n + 1, sizeof(int));
+    }
+    
+    int max = 0;
+    
+    // Fill the dp array based on the matrix values
+    for (int i = 1; i <= m; i++) {
+        for (int j = 1; j <= n; j++) {
+            if (matrix[i - 1][j - 1] == '1') {
+                dp[i][j] = 1 + min3(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+                if (dp[i][j] > max) {
+                    max = dp[i][j];
+                }
+            }
+        }
+    }
+    
+    // Free allocated memory for dp array
+    for (int i = 0; i <= m; i++) {
+        free(dp[i]);
+    }
+    free(dp);
+    
+    return max * max;
+}
+```

src/main/c/g0201_0300/s0221_maximal_square/readme.md

@@ -0,0 +1,87 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/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
+
+```c
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+// Function to invert a binary tree
+struct TreeNode* invertTree(struct TreeNode* root) {
+    if (root == NULL) {
+        return NULL;
+    }
+    // Swap the left and right children
+    struct TreeNode* temp = root->left;
+    root->left = invertTree(root->right);
+    root->right = invertTree(temp);
+    return root;
+}
+
+// Helper function to create a new tree node
+struct TreeNode* createNode(int val) {
+    struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
+    newNode->val = val;
+    newNode->left = NULL;
+    newNode->right = NULL;
+    return newNode;
+}
+
+// Helper function to print the tree in order (for testing purposes)
+void printInOrder(struct TreeNode* root) {
+    if (root == NULL) return;
+    printInOrder(root->left);
+    printf("%d ", root->val);
+    printInOrder(root->right);
+}
+
+// Helper function to free the tree memory
+void freeTree(struct TreeNode* root) {
+    if (root == NULL) return;
+    freeTree(root->left);
+    freeTree(root->right);
+    free(root);
+}
+```

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

@@ -0,0 +1,99 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/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
+
+```c
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+// Helper struct to hold state across recursive calls
+struct Solution {
+    int k;
+    int count;
+    int val;
+};
+
+// Function to create a new tree node
+struct TreeNode* createNode(int val) {
+    struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
+    newNode->val = val;
+    newNode->left = NULL;
+    newNode->right = NULL;
+    return newNode;
+}
+
+// Helper function to perform in-order traversal and find the k-th smallest element
+void calculate(struct Solution* sol, struct TreeNode* node) {
+    if (node == NULL || sol->count >= sol->k) {
+        return;
+    }
+
+    if (node->left != NULL) {
+        calculate(sol, node->left);
+    }
+
+    sol->count++;
+    if (sol->count == sol->k) {
+        sol->val = node->val;
+        return;
+    }
+
+    if (node->right != NULL) {
+        calculate(sol, node->right);
+    }
+}
+
+// Function to find the k-th smallest element in the BST
+int kthSmallest(struct TreeNode* root, int k) {
+    struct Solution sol = {k, 0, 0};
+    calculate(&sol, root);
+    return sol.val;
+}
+
+// Helper function to free the tree memory
+void freeTree(struct TreeNode* root) {
+    if (root == NULL) return;
+    freeTree(root->left);
+    freeTree(root->right);
+    free(root);
+}
+```

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

@@ -0,0 +1,87 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/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
+
+```c
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     struct ListNode *next;
+ * };
+ */
+#include <stdbool.h>
+
+// Function to check if the linked list is a palindrome
+bool isPalindrome(struct ListNode* head) {
+    if (head == NULL || head->next == NULL) {
+        return true;
+    }
+
+    // Step 1: Calculate the length of the list
+    int len = 0;
+    struct ListNode* right = head;
+    while (right != NULL) {
+        right = right->next;
+        len++;
+    }
+
+    // Step 2: Find the middle of the list and reverse the right half
+    len = len / 2;
+    right = head;
+    for (int i = 0; i < len; i++) {
+        right = right->next;
+    }
+
+    // Reverse the right half of the list
+    struct ListNode* prev = NULL;
+    while (right != NULL) {
+        struct ListNode* next = right->next;
+        right->next = prev;
+        prev = right;
+        right = next;
+    }
+
+    // Step 3: Compare the left half and the reversed right half
+    struct ListNode* left = head;
+    while (prev != NULL) {
+        if (left->val != prev->val) {
+            return false;
+        }
+        left = left->next;
+        prev = prev->next;
+    }
+
+    return true;
+}
+```

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

@@ -0,0 +1,79 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 236\. Lowest Common Ancestor of a Binary Tree
+
+Medium
+
+Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.
+
+According to the [definition of LCA on Wikipedia](https://en.wikipedia.org/wiki/Lowest_common_ancestor): “The lowest common ancestor is defined between two nodes `p` and `q` as the lowest node in `T` that has both `p` and `q` as descendants (where we allow **a node to be a descendant of itself**).”
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/12/14/binarytree.png)
+
+**Input:** root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
+
+**Output:** 3
+
+**Explanation:** The LCA of nodes 5 and 1 is 3.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2018/12/14/binarytree.png)
+
+**Input:** root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
+
+**Output:** 5
+
+**Explanation:** The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.
+
+**Example 3:**
+
+**Input:** root = [1,2], p = 1, q = 2
+
+**Output:** 1
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.
+*   <code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code>
+*   All `Node.val` are **unique**.
+*   `p != q`
+*   `p` and `q` will exist in the tree.
+
+## Solution
+
+```c
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+// Function to find the lowest common ancestor of two nodes in the binary tree
+struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) {
+    // Base case: if the root is NULL or root matches either p or q
+    if (root == NULL || root == p || root == q) {
+        return root;
+    }
+
+    // Recursively find the LCA in the left and right subtrees
+    struct TreeNode* left = lowestCommonAncestor(root->left, p, q);
+    struct TreeNode* right = lowestCommonAncestor(root->right, p, q);
+
+    // If both left and right are non-null, the current root is the LCA
+    if (left != NULL && right != NULL) {
+        return root;
+    }
+
+    // Otherwise, return the non-null child (if both are NULL, return NULL)
+    return left != NULL ? left : right;
+}
+```

src/main/c/g0201_0300/s0236_lowest_common_ancestor_of_a_binary_tree/readme.md

@@ -0,0 +1,69 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/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
+
+```c
+#include <stdio.h>
+
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+int* productExceptSelf(int* nums, int numsSize, int* returnSize) {
+    int* ans = (int*)malloc(numsSize * sizeof(int));
+    int product = 1;
+
+    // Calculate the product of all elements
+    for (int i = 0; i < numsSize; i++) {
+        product *= nums[i];
+    }
+
+    // Calculate the result for each element
+    for (int i = 0; i < numsSize; i++) {
+        if (nums[i] != 0) {
+            ans[i] = product / nums[i];
+        } else {
+            int p = 1;
+            for (int j = 0; j < numsSize; j++) {
+                if (j != i) {
+                    p *= nums[j];
+                }
+            }
+            ans[i] = p;
+        }
+    }
+
+    *returnSize = numsSize;
+    return ans;
+}
+```

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

@@ -0,0 +1,94 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/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
+
+```c
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+int* maxSlidingWindow(int* nums, int numsSize, int k, int* returnSize) {
+    if (k == 1) {
+        *returnSize = numsSize;
+        return nums;
+    }
+
+    int *queue = malloc(sizeof(int) * numsSize);
+    int *res = malloc(sizeof(int) * (numsSize - k + 1));
+    int rear = -1;
+    int qLen = 0;
+    int front = 0;
+    int i = 0;
+    int resCount = 0;
+
+    for (i = 0; i < numsSize; i++) {
+        // Remove elements that are out of the window
+        while (qLen > 0 && i - queue[front] >= k) {
+            front++;
+            qLen--;
+        }
+
+        // Remove elements from the back of the queue that are less than the current element
+        while (qLen > 0 && nums[i] > nums[queue[rear]]) {
+            rear--;
+            qLen--;
+        }
+
+        // Add the current element index to the queue
+        queue[++rear] = i;
+        qLen++;
+
+        // Once we have a complete window, add the maximum element (from the front of the queue) to the result
+        if (i >= k - 1) {
+            res[resCount++] = nums[queue[front]];
+        }
+    }
+
+    *returnSize = resCount;
+    return res;
+}
+```