Update sortColors doc

Author: sudheerj

README.md

@@ -51,8 +51,8 @@ List of Programs related to data structures and algorithms
    6. Minimum size subarray sum: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/6.minimumSizeSubarraySum/minSizeSubarraySum.js) 
    [Playground](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/6.minimumSizeSubarraySum/minSizeSubarraySum.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/6.minimumSizeSubarraySum/minSizeSubarraySum.md)
 
-   7. Sort Colors: [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/sortColors/sortColors.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/sortColors/sortColors.md)
-
+   7. Sort Colors: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/7.sortColors/sortColors.js) 
+   [Playground](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/7.sortColors/sortColors.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/7.sortColors/sortColors.md)
 
    8. Maximum product subarray: [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/maxProductSubArray.js)
 

src/java1/algorithms/array/sortColors/SortColors.java

@@ -31,8 +31,8 @@ private static void swap(int[] nums, int i, int j) {
     }
 
     public static void main(String[] args) {
-        int[] nums1 = {2,0,2,1,1,0};
-        int[] nums2 = {2,0,1};
+        int[] nums1 = {2,1,0,1,2,0};
+        int[] nums2 = {2,1,0};
         System.out.println(Arrays.toString(sortColors(nums1)));
         System.out.println(Arrays.toString(sortColors(nums2)));
 

src/java1/algorithms/array/sortColors/SortColors.md

@@ -1,20 +1,40 @@
-**Algorithmic Steps**
-This problem is solved with the help of two pointers technique. It is also know as "Dutch National Flag problem". The algorithmic approach can be summarized as follows:
+**Description:**
+Given an array `nums` with `n` objects colored red, white, where each object is color coded as integer: blue, 0 for red, 1 for white, and 2 for blue. We need to sort them in-place so that objects of the same color are grouped together, with the colors in the order red, white, and blue.
 
+This problem needs to be solved without using the library's sort function.
 
-1. Initialize left and right pointers to first(i.e, 0) and end index of the array, to keep track of the current window boundaries.
+### Examples
 
-3. Initialize current index pointer(i.e, i) to 0, to keep track of the current character while iterating the array.
+Example 1:
 
-4. Iterate over the input array using index pointer until the end of the array. 
+Input: nums = [2,1,0,1,2,0]
+Output: [0,0,1,1,2,2]
 
-5. If the current character is equals to 0, swap the character values at left pointer and index pointer. Also, increment the left pointer and index pointer.
+Example 2:
 
-6. If the current character is equals to 2, swap the character values at right pointer and index pointer. Also, decrement the right pointer. If the chracter is neither 0 or 2, then just increment the index pointer.
+Input: nums = [2,1,0]
+Output: [0,1,2]
 
-8. Repeat steps 5–6 until the index pointer reaches the end of the array.
+**Algorithmic Steps:**
 
-9. Return the updated in-place array where chracters are sorted.
+This problem is solved with the help of **two pointers** technique. It is also know as **"Dutch National Flag problem"**. The algorithmic approach can be summarized as follows:
+
+
+1. Initialize both left and right pointers to first index(i.e, `0`) and end index(i.e, `nums.length-1`) of the array respectively, to keep track of the current window boundaries.
+
+2. Initialize current index pointer(i.e, `i`) to 0, to keep track of the current character while iterating the array.
+
+3. Iterate over the input array using index pointer until the end of the array. 
+
+4. If the current character is equals to 0, swap the character values at left pointer and index pointer. Also, increment the left pointer and index pointer.
+
+5. If the current character is equals to 2, swap the character values at right pointer and index pointer. Also, decrement the right pointer. 
+
+6. If the chracter is neither `0` or `2`, then just increment the index pointer.
+
+7. Repeat steps 4–6 until the index pointer reaches the end of the array.
+
+8. Return the updated in-place array where chracters are sorted.
 
 **Time and Space complexity:**
-This algorithm has a time complexity of O(n) because we are traversing the array only once. Also, it takes requires space complexity of O(1) because we are updating the array in-place without using an additional array.
+This algorithm takes a time complexity of `O(n)` because we are traversing the array only once. Also, it requires space complexity of `O(1)` because we are updating the array in-place without using an additional data structure.

src/javascript/algorithms/array/sortColors/sortColors.js renamed to src/javascript/algorithms/array/7.sortColors/sortColors.js

@@ -26,8 +26,8 @@ function swap(nums, one, two) {
     nums[two] = temp;
 }
 
-let nums1 = [2,0,2,1,1,0];
+let nums1 = [2,1,0,1,2,0];
 console.log(sortColors(nums1));
 
-let nums2 = [2,0,1];
+let nums2 = [2,1,0];
 console.log(sortColors(nums2));

src/javascript/algorithms/array/7.sortColors/sortColors.md

@@ -0,0 +1,40 @@
+**Description:**
+Given an array `nums` with `n` objects colored red, white, where each object is color coded as integer: blue, 0 for red, 1 for white, and 2 for blue. We need to sort them in-place so that objects of the same color are grouped together, with the colors in the order red, white, and blue.
+
+This problem needs to be solved without using the library's sort function.
+
+### Examples
+
+Example 1:
+
+Input: nums = [2,1,0,1,2,0]
+Output: [0,0,1,1,2,2]
+
+Example 2:
+
+Input: nums = [2,1,0]
+Output: [0,1,2]
+
+**Algorithmic Steps:**
+
+This problem is solved with the help of **two pointers** technique. It is also know as **"Dutch National Flag problem"**. The algorithmic approach can be summarized as follows:
+
+
+1. Initialize both left and right pointers to first index(i.e, `0`) and end index(i.e, `nums.length-1`) of the array respectively, to keep track of the current window boundaries.
+
+2. Initialize current index pointer(i.e, `i`) to 0, to keep track of the current character while iterating the array.
+
+3. Iterate over the input array using index pointer until the end of the array. 
+
+4. If the current character is equals to 0, swap the character values at left pointer and index pointer. Also, increment the left pointer and index pointer.
+
+5. If the current character is equals to 2, swap the character values at right pointer and index pointer. Also, decrement the right pointer. 
+
+6. If the chracter is neither `0` or `2`, then just increment the index pointer.
+
+7. Repeat steps 4–6 until the index pointer reaches the end of the array.
+
+8. Return the updated in-place array where chracters are sorted.
+
+**Time and Space complexity:**
+This algorithm takes a time complexity of `O(n)` because we are traversing the array only once. Also, it requires space complexity of `O(1)` because we are updating the array in-place without using an additional data structure.