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);
+}
+```