Update min rotated sorted array logic

Author: sudheerj

README.md

@@ -57,7 +57,8 @@ List of Programs related to data structures and algorithms
    8. Maximum product subarray: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/8.maxProductSubarray/maxProductSubarray.js) 
    [Playground](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/8.maxProductSubarray/maxProductSubarray.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/8.maxProductSubarray/maxProductSubarray.md)
 
-   9. Find minimum in rotated sorted array: [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/minRotatedSortedArray.js)
+   9. Find minimum in rotated sorted array: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/9.minRotatedSortedarray/minRotatedSortedarray.js) 
+   [Playground](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/9.minRotatedSortedarray/minRotatedSortedarray.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/9.minRotatedSortedarray/minRotatedSortedarray.md)
 
    10. Maximum Circular subarray: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/maxCircularSubArray.js)
 

src/java1/algorithms/array/MinimumRotatedSortedArray.java renamed to src/java1/algorithms/array/minimumRotatedSortedarray/MinimumRotatedSortedarray.java

@@ -1,31 +1,32 @@
+package minimumRotatedSortedarray;
 //TC: O(log n), SC: O(1)
 
-public class MinimumRotatedSortedArray {
+public class MinimumRotatedSortedarray {
     private static int minRotatedSortedArray(int[] nums) {
+        int result = nums[0];
+
         if (nums.length == 1)
-            return nums[0];
+            return result;
         if (nums.length == 2)
             return Math.min(nums[0], nums[1]);
 
         int left = 0, right = nums.length - 1;
-        if (nums[left] < nums[right]) {
-            return nums[left];
-        }
 
         while (left <= right) {
+            if (nums[left] <= nums[right]) {
+                result = nums[left];
+                break;
+            }
+
             int mid = left + (right - left) / 2;
-            if (nums[mid] > nums[mid + 1])
-                return nums[mid + 1];
-            if (nums[mid - 1] > nums[mid])
-                return nums[mid];
 
-            if (nums[left] < nums[mid]) {
+            if (nums[mid] > nums[right]) {
                 left = mid + 1;
             } else {
-                right = mid - 1;
+                right = mid;
             }
         }
-        return 0;
+        return result;
     }
 
     public static void main(String[] args) {

src/java1/algorithms/array/minimumRotatedSortedarray/minimumRotatedSortedarray.md

@@ -0,0 +1,43 @@
+**Description:**
+Given a sorted array `nums` of length `n` with all unique elements, in which the array is rotated between 1 and n times. Return the minimum element of this array.
+
+**Note:** You need to write an algorithm that runs in O(log n) time.
+
+### Examples
+Example 1:
+Input: nums = [3, 4, 5, 6, 7, 1, 2]
+Output: 1
+
+Example 2:
+Input: nums = [ 0, 1, 2, 4, 5, 6, 7, 8]
+Output: 0
+
+**Algorithmic Steps:**
+
+This problem is solved with the help of binary search technique. Since it is a rotated sorted array, there will be two subararys of elements in an ascending order. Once you find the correct subarray, the left most element is the minimum value. The algorithmic approach can be summarized as follows:
+
+1. Initialize the minimum value(`result`) to first element of an array.
+
+2. Add preliminary checks by returning the first element if the length of array is one, or minimum of first two values if the length of an array is two.
+
+3. Initialize left and right pointers(`left` and `right`) to first index and last index of an array.
+
+4. Iterate over an input array using while loop with the condition of left pointer is less than or equal to right pointer.
+
+5. If the left element is less than or equal to right element, update the result value and break the while loop to return the minimum value.
+
+6. Calculate the middle index of an array to separate the sorted subarrays.
+
+7. If the middle value is greater than right most element, the minimum value exists with in the right side subarray. So the left pointer will be updated to next element of middle element.
+
+8. If the middle value is less than or equal to left most element, the minimum value exists with in the left side subarray. So the right pointer will be updated to the middle element.
+
+9. Repeat steps 4-7 until you find the left most value which is minimum in the entire input array.
+
+10. Return the result element after the end of an iteration.
+
+**Time and Space complexity:**
+
+This algorithm has a time complexity of `O(log n)`, where `n` is the number of elements. This is because we divide the array into two subarray each time and find the minimum element in the correct subarray using binary search alogorithm. 
+
+Here, we don't use any additional datastructure other than the result variable. Hence, the space complexity will be O(1).

src/javascript/algorithms/array/8.maxProductSubarray/maxProductSubarray.md

@@ -20,7 +20,7 @@ This problem is solved with the help of Kadane's algorithm(dynamic programming t
 
 2. Initialize two variables named `currentMax` and `currentMin` to `1`. They are used to keep track of the running maximum and minimum products.
 
-3. Iterate over the entire input array using for-each loop
+3. Iterate over the entire input array using for-of loop
 
 4. Find the temporary maximum and minimum products for each current element.
 

src/javascript/algorithms/array/minRotatedSortedArray.js renamed to src/javascript/algorithms/array/9.minRotatedSortedarray/minRotatedSortedarray.js

@@ -1,23 +1,25 @@
 function minRotatedSortedArray(nums) {
+    let result = nums[0];
     if(nums.length === 1) return nums[0];
     if(nums.length === 2) return Math.min(nums[0], nums[1]);
 
     let left = 0, right = nums.length - 1;     
-    if(nums[left] < nums[right]) return nums[left];
 
-    while(left <= right) {
-        let mid = left + (right - left)/2;
+    while(left < right) {
+        if(nums[left] < nums[right]) {
+            result = nums[left];
+            break;
+        }
 
-        if(nums[mid] > nums[mid+1]) return nums[mid+1];
-        if(nums[mid-1] > nums[mid]) return nums[mid];
+        let mid = left + (right - left)/2;
 
-        if(nums[left] < nums[mid]) {
+        if(nums[mid] > nums[right]) {
             left = mid + 1;
         } else {
-            right = mid - 1;
+            right = mid;
         }
     }
-    return 0;
+    return result;
 }
 
 let sortedArray = [3, 4, 5, 6, 7, 1, 2];

src/javascript/algorithms/array/9.minRotatedSortedarray/minRotatedSortedarray.md

@@ -0,0 +1,43 @@
+**Description:**
+Given a sorted array `nums` of length `n` with all unique elements, in which the array is rotated between 1 and n times. Return the minimum element of this array.
+
+**Note:** You need to write an algorithm that runs in O(log n) time.
+
+### Examples
+Example 1:
+Input: nums = [3, 4, 5, 6, 7, 1, 2]
+Output: 1
+
+Example 2:
+Input: nums = [ 0, 1, 2, 4, 5, 6, 7, 8]
+Output: 0
+
+**Algorithmic Steps:**
+
+This problem is solved with the help of binary search technique. Since it is a rotated sorted array, there will be two subararys of elements in an ascending order. Once you find the correct subarray, the left most element is the minimum value. The algorithmic approach can be summarized as follows:
+
+1. Initialize the minimum value(`result`) to first element of an array.
+
+2. Add preliminary checks by returning the first element if the length of array is one, or minimum of first two values if the length of an array is two.
+
+3. Initialize left and right pointers(`left` and `right`) to first index and last index of an array.
+
+4. Iterate over an input array using while loop with the condition of left pointer is less than or equal to right pointer.
+
+5. If the left element is less than or equal to right element, update the result value and break the while loop to return the minimum value.
+
+6. Calculate the middle index of an array to separate the sorted subarrays.
+
+7. If the middle value is greater than right most element, the minimum value exists with in the right side subarray. So the left pointer will be updated to next element of middle element.
+
+8. If the middle value is less than or equal to left most element, the minimum value exists with in the left side subarray. So the right pointer will be updated to the middle element.
+
+9. Repeat steps 4-7 until you find the left most value which is minimum in the entire input array.
+
+10. Return the result element after the end of an iteration.
+
+**Time and Space complexity:**
+
+This algorithm has a time complexity of `O(log n)`, where `n` is the number of elements. This is because we divide the array into two subarray each time and find the minimum element in the correct subarray using binary search alogorithm. 
+
+Here, we don't use any additional datastructure other than the result variable. Hence, the space complexity will be O(1).