Update searchRotateSortedArray logic

Author: sudheerj

src/javascript/algorithms/array/11.rotateArray/rotateArray.md

@@ -12,7 +12,15 @@ Example 2:
 Input: nums = [-10, 4, 5, -1], n = 2
 Output: [5, -1, -10, 4]
 
+Example 3 (Edge Case):
+
+Input: nums = [1], n = 10
+Output: [1] (Single element array remains unchanged regardless of rotation count)
+
 **Algorithm overview:**
+This problem can be solved using two different approaches:
+
+### Approach 1: Reversal Technique (Efficient)
 This algorithm leverages the **reversal technique** (a two-pointer approach) to efficiently rotate the array in-place.
 
 To rotate the array to the right by `n` steps:
@@ -26,14 +34,18 @@ To rotate the array to the right by `n` steps:
 1. **Calculate Array Length**  
    Initialize a variable `length` to store the total number of elements in the array.
 
-2. **Edge case**
-   No rotation is required when the given array is empty and number of rotations is equals to the length of an array. This condition is helpful for early exit.
-   
+2. **Handle Edge Cases**
+   No rotation is required when:
+   - The array is empty
+   - The rotation count is 0
+   - The rotation count is equal to the array length (full rotation returns to original state)
+   This condition is helpful for early exit.
+
 3. **Normalize the Rotation Count**  
    Update the rotation count by taking `n % length` to handle cases where `n` exceeds the array size. This ensures we perform only the necessary rotations.
 
 4. **Define a Reversal Helper Function**  
-   Implement a helper function that reverses elements between two indices (`left` and `right`) in the array using a two-pointer technique. Swap the elements at `left` and `right`, then increment `left` and decrement `right` in each iteration until both pointers meet.
+   Implement a helper function that reverses elements between two indices (`start` and `end`) in the array using a two-pointer technique. Swap the elements at `start` and `end`, then increment `start` and decrement `end` in each iteration until both pointers meet.
 
 5. **Reverse the Entire Array**  
    Apply the reversal function to the full array (from index `0` to `length - 1`). This step brings the elements that need to be rotated to the front, but in reverse order.
@@ -47,11 +59,40 @@ To rotate the array to the right by `n` steps:
 8. **Return the Rotated Array**  
    The array has now been successfully rotated in-place and is ready for use.
 
+### Approach 2: Brute Force Method
+This approach uses JavaScript's array methods to perform the rotation one step at a time.
+
+#### Detailed steps:
+
+1. **Calculate Array Length**  
+   Initialize a variable `length` to store the total number of elements in the array.
+
+2. **Handle Empty Array**
+   Return immediately if the array is empty.
+
+3. **Normalize the Rotation Count**  
+   Update the rotation count by taking `n % length` to handle cases where `n` exceeds the array size.
+
+4. **Perform Rotation**  
+   For each of the `n` steps:
+   - Remove the last element of the array using `pop()`
+   - Insert this element at the beginning of the array using `unshift()`
+
+5. **Array is Rotated**  
+   After `n` iterations, the array has been rotated to the right by `n` positions.
+
 ## Time and Space Complexity
 
+### Approach 1 (Reversal Technique):
 - **Time Complexity:** `O(n)`  
   The algorithm performs three reverse operations, each taking `O(n)` time in total.
 
 - **Space Complexity:** `O(1)`  
   The rotation is done in-place, using only a constant amount of extra space regardless of input size.
 
+### Approach 2 (Brute Force):
+- **Time Complexity:** `O(n²)`  
+  For each of the `n` rotations, the `unshift()` operation takes `O(n)` time as it requires shifting all elements.
+
+- **Space Complexity:** `O(1)`  
+  The rotation is done in-place, modifying the original array.

src/javascript/algorithms/array/12.searchRotatedSortedArray/searchRotatedSortedArray.js

@@ -1,31 +1,41 @@
-// TC: O(log n), SC: O(1)
+/**
+ * Searches for a target in a rotated sorted array.
+ * Returns the index of the target if found, otherwise -1.
+ * Time Complexity: O(log n)
+ * Space Complexity: O(1)
+ */
 function searchRotatedSortedArray(nums, target) {
     let left = 0;
     let right = nums.length - 1;
 
-    while(left <= right) {
-        let mid = Math.floor(left + (right-left)/2);
-        if(nums[mid] === target) {
-            return mid;
-        }
+    while (left <= right) {
+        const mid = Math.floor((left + right) / 2);
+
+        // Found the target
+        if (nums[mid] === target) return mid;
 
-        if(nums[left] <= nums[mid]) { // Left to mid is sorted
-            if(nums[left] <= target && target < nums[mid]) {
-                right = mid - 1;
+        // Determine which half is sorted
+        if (nums[left] <= nums[mid]) {
+            // Left side is sorted
+            if (nums[left] <= target && target < nums[mid]) {
+                right = mid - 1; // Target in left half
             } else {
-                left = mid + 1;
+                left = mid + 1; // Target in right half
             }
-        } else { // Mid to right is sorted
-            if(nums[mid] < target && target <= nums[right]) {
-                left = mid + 1;
+        } else {
+            // Right side is sorted
+            if (nums[mid] < target && target <= nums[right]) {
+                left = mid + 1; // Target in right half
             } else {
-                right = mid - 1;
+                right = mid - 1; // Target in left half
             }
         }
     }
-    return -1;
+
+    return -1; // Target not found
 }
 
+
 let nums = [3, 4, 5, 6, 7, 0, 1, 2];
 console.log(searchRotatedSortedArray(nums, 7));
 

src/javascript/algorithms/array/12.searchRotatedSortedArray/searchRotatedSortedArray.md

@@ -1,40 +1,66 @@
 **Description:**
-Given a sorted array `nums` in an ascending order, which is rotated at some known pivot index. You need to search for a given `target` value, if found in the array return it's index otherwise return -1.
+Given a sorted array `nums` in ascending order that has been rotated at an unknown pivot point, search for a target value. If the target is found in the array, return its index; otherwise, return -1.
 
-**Note:** There are no duplicate values exist. The runtime complexity should be O(log n).
+**Note:** The array contains no duplicate values. The solution should have a runtime complexity of O(log n).
 
 ### Examples
-
 Example 1:
+
 Input: nums = [3, 4, 5, 6, 7, 0, 1, 2], target = 7
 Output: 4
 
 Example 2:
+
 Input: nums = [3, 4, 5, 6, 7, 0, 1, 2], target = 9
 Output: -1
 
-**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. You can decide the presence of target element by verifying either in left side subarray or right side subarray. The algorithmic approach can be summarized as follows:
+Example 3 (Edge Case):
+
+Input: nums = [1], target = 1
+Output: 0
+
+**Algorithm overview:**
+This problem is solved using a modified **binary search** technique. In a rotated sorted array, there are two sorted subarrays. The key insight is to determine which subarray is sorted and then check if the target lies within that sorted portion.
+
+#### Detailed steps:
 
-1. Initialize left(`left`) and right pointers(`right`) to the beginning and ending index of an array.
+1. **Initialize Pointers**  
+   Set `left` pointer to the beginning (index 0) and `right` pointer to the end (index length-1) of the array.
 
-2. Iterate over input array until either left pointer reaches right pointer or target element found.
+2. **Binary Search Loop**  
+   Continue searching while `left` pointer is less than or equal to `right` pointer.
 
-3. Calculate the middle index of the array to divide into two equal subarrays.
+3. **Find Middle Element**  
+   Calculate the middle index using `mid = Math.floor((left + right) / 2)`.
 
-4. If the middle element is equals to target, return the middle element index as output.
+4. **Check for Target Match**  
+   If the middle element equals the target (`nums[mid] === target`), return the middle index immediately.
 
-5. If the left element is less than or equal to middle element(i.e, `nums[left] <= nums[mid]`), the left portion of input array is sorted. In this case, if the target element exists between left and middle elements, update the right pointer to the element before the middle element(`right = mid-1`). This logic indicates that target exists with in first subarray. Otherwise update the left pointer to the element just after the middle element(`left = mid+1`) to indicate the target exists with in second subarray.
+5. **Determine Which Half is Sorted**  
+   - If `nums[left] <= nums[mid]`, the left half is sorted.
+   - Otherwise, the right half is sorted.
 
-6. In the same way, if the right element is greater than or equal to right element(i.e, `nums[mid] <= nums[right]`), the right portion of input array is sorted. In this case, if the target element exists between right and middle elements, update the left pointer to the element after the middle element(`left = mid+1`). This logic indicates that target exists with in second subarray. Otherwise update the right pointer to the element just before the middle element(`right = mid-1`) to indicate the target exists with in first subarray.
+6. **Search in Sorted Half**  
+   - If the left half is sorted:
+     - Check if the target is within the range `nums[left]` to `nums[mid-1]`.
+     - If yes, search the left half by setting `right = mid - 1`.
+     - If no, search the right half by setting `left = mid + 1`.
 
-7. Repeat steps 4-6 element found or until end of array reached.
+   - If the right half is sorted:
+     - Check if the target is within the range `nums[mid+1]` to `nums[right]`.
+     - If yes, search the right half by setting `left = mid + 1`.
+     - If no, search the left half by setting `right = mid - 1`.
 
-8. Return -1, if the target doesn't exist with in input array.
+7. **Repeat or Return**  
+   Repeat steps 3-6 until either the target is found or the search space is exhausted.
 
+8. **Not Found Case**  
+   If the loop terminates without finding the target, return -1.
 
-**Time and Space complexity:**
+## 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 subarrays each time and find the index of target element using binary search algorithm. 
+- **Time Complexity:** `O(log n)`  
+  The algorithm uses a binary search approach, dividing the search space in half with each iteration. Even though the array is rotated, we can still determine which half to search in constant time.
 
-Here, we don't use any additional datastructure other than two left pointer variables. Hence, the space complexity will be O(1).
+- **Space Complexity:** `O(1)`  
+  The algorithm uses only a constant amount of extra space regardless of input size, as it only requires a few variables (`left`, `right`, and `mid`) to track the search space.

src/javascript/algorithms/array/31.thirdLargestElement/thirdLargestElement.md

@@ -0,0 +1,42 @@
+**Description:**
+Given an array of integers, find the third largest element in the array. If there are fewer than three unique elements, return a message indicating that there are not enough unique elements.
+
+### Examples
+Example 1:
+
+Input: [33, 90, 10, 50, 33, 77, 90, 4]
+Output: 50
+
+Example 2:
+
+Input: [1, 2]
+Output: "There are no 3 unique elements in an array"
+
+**Algorithmic Steps**
+This problem can be solved using two different approaches:
+
+**Approach 1: Single Pass Tracking**
+1. Initialize three variables to track the first, second, and third largest elements, all set to negative infinity.
+2. Iterate through each number in the array:
+   - Skip if the number is equal to any of the three largest elements (to handle duplicates)
+   - If the number is greater than the first largest, update all three variables accordingly
+   - If the number is greater than the second largest but less than the first, update the second and third largest
+   - If the number is greater than the third largest but less than the second, update only the third largest
+3. After the iteration, if the third largest is still negative infinity, return a message indicating there are not enough unique elements
+4. Otherwise, return the third largest element
+
+**Approach 2: Using Set and Sort**
+1. Create a Set from the array to remove duplicates
+2. Convert the Set back to an array
+3. If the array length is less than 3, return a message indicating there are not enough unique elements
+4. Sort the array in descending order
+5. Return the element at index 2 (third element)
+
+**Time and Space complexity:**
+**Approach 1 (Single Pass Tracking):**
+- Time Complexity: O(n), where n is the length of the array, as we only need to iterate through the array once.
+- Space Complexity: O(1), as we only use three variables regardless of the input size.
+
+**Approach 2 (Using Set and Sort):**
+- Time Complexity: O(n log n), dominated by the sorting operation.
+- Space Complexity: O(n) for storing the unique elements in the Set.