Add rotate array in java

Author: sudheerj

README.md

@@ -63,7 +63,8 @@ List of Programs related to data structures and algorithms
    10. Maximum Circular subarray: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/10.maxSumCircularSubArray/maxSumCircularSubArray.js) 
    [Playground](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/10.maxSumCircularSubArray/maxSumCircularSubArray.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/10.maxSumCircularSubArray/maxSumCircularSubArray.md)
 
-   11. Rotate array: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/rotate.js)
+   11. Rotate array: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/11.rotateArray/rotateArray.js) 
+   [Playground](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/11.rotateArray/rotateArray.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/11.rotateArray/rotateArray.md)
 
    12. Search in rotated sorted array: [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/searchRotatedSortedArray.js)
 

src/java1/algorithms/array/rotateArray/RotateArray.java

@@ -0,0 +1,41 @@
+package rotateArray;
+
+import java.util.Arrays;
+
+public class RotateArray {
+
+    private static int[] rotate(int[] nums, int n) {
+        int length = nums.length;
+        n %= length;
+
+        reversal(nums, 0, length-1);
+        reversal(nums, 0, n-1);
+        reversal(nums, n, length-1);
+
+        return nums;
+    }
+
+    private static void reversal(int[] nums, int start, int end) {
+        while(start < end) {
+            int temp = nums[start];
+            nums[start] = nums[end];
+            nums[end] = temp;
+
+            start++;
+            end--;
+        }
+    }
+
+
+    public static void main(String[] args) {
+        int[] rotate1 = {1, 2, 3, 4, 5, 6, 7};
+        System.out.println("Before rotate: "+ Arrays.toString(rotate1));
+        rotate(rotate1, 4);
+        System.out.println("After rotate: "+ Arrays.toString(rotate1));
+
+        int[] rotate2 = {-10, 4, 5, -1};
+        System.out.println("Before rotate: "+ Arrays.toString(rotate2));
+        rotate(rotate2, 2);
+        System.out.println("After rotate: "+ Arrays.toString(rotate2));   
+    }
+}

src/java1/algorithms/array/rotateArray/RotateArray.md

@@ -0,0 +1,37 @@
+**Description**
+Given an integer array `nums`, rotate the array to the right by `n` steps, where `n` is non-negative number.
+
+### Examples
+Example 1:
+
+Input: nums = [1,2,3,4,5,6,7], n = 4
+Output: [5,6,7,1,2,3,4]
+
+Example 2:
+
+Input: nums = [-10, 4, 5, -1], n = 2
+Output: [5, -1, -10, 4]
+
+**Algorithmic Steps:**
+This problem is solved with the help of two pointers, which is used to reverse subarrays. The algorithmic approach can be summarized as follows:
+
+1. Initialize `length` variable to store length of an input array.
+
+2. Update the number of times rotation(i.e, `n`) to `n % length` incase of number of rotations greater than length of an array.
+
+3. Create a helper function to reverse elements of an array using swap operation with the help left and right pointers(i.e, `left` and `right`). The left pointer needs to be incremented and right pointer needs to decremented for each iteration.
+
+4. Invoke reversal operation for entire array of elements(i.e, from the beggining to end of an array).
+
+5. Invoke reversal operation for first `n` number of elements(i.e, from the beggining to n-1).
+
+6. Invoke reversal operation for remaining number of elements(i.e, from `n-1` to end of an array).
+
+7. Return in-place rotated array as output.
+
+**Time and Space complexity:**
+
+This algorithm has a time complexity of `O(n)`, where `n` is the number of elements. This is because we are performing three reversal operations on subarrays and each reversal operation takes O(n). So the overall time complexity is O(n). 
+
+Here, we don't use any additional datastructure due to in-place rotation. Hence, the space complexity will be O(1).
+

src/javascript/algorithms/array/rotate.js renamed to src/javascript/algorithms/array/11.rotateArray/rotateArray.js

@@ -1,11 +1,13 @@
-// 1. Reversal approach
+// 1. Reversal approach using two pointers
 function rotate(nums, n) {
     const length = nums.length;
     n %= length;
 
     reversal(nums, 0, length-1);
     reversal(nums, 0, n-1);
     reversal(nums, n, length-1);
+
+    return nums;
 }
 
 function reversal(nums, start, end) {
@@ -25,11 +27,11 @@ function rotateBrutforce(nums, n) {
 }
 
 let rotate1 = [1, 2, 3, 4, 5, 6, 7];
-console.log("Before rotate:         ", rotate1.join(", "));
+console.log("Before rotate:", rotate1);
 rotate(rotate1, 4);
-console.log("After rotate:   ", rotate1.join(", "));
+console.log("After rotate:", rotate1);
 
-let rotate2 = [1, 2, 3, 4, 5, 6, 7];
-console.log("Before rotate:         ", rotate2.join(", "));
-rotateBrutforce(rotate2, 4);
-console.log("After rotate:   ", rotate2.join(", "));
+let rotate2 = [-10, 4, 5, -1];
+console.log("Before rotate:", rotate2);
+rotateBrutforce(rotate2, 2);
+console.log("After rotate:", rotate2.join);

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

@@ -0,0 +1,37 @@
+**Description**
+Given an integer array `nums`, rotate the array to the right by `n` steps, where `n` is non-negative number.
+
+### Examples
+Example 1:
+
+Input: nums = [1,2,3,4,5,6,7], n = 4
+Output: [5,6,7,1,2,3,4]
+
+Example 2:
+
+Input: nums = [-10, 4, 5, -1], n = 2
+Output: [5, -1, -10, 4]
+
+**Algorithmic Steps:**
+This problem is solved with the help of two pointers, which is used to reverse subarrays. The algorithmic approach can be summarized as follows:
+
+1. Initialize `length` variable to store length of an input array.
+
+2. Update the number of times rotation(i.e, `n`) to `n % length` incase of number of rotations greater than length of an array.
+
+3. Create a helper function to reverse elements of an array using swap operation with the help left and right pointers(i.e, `left` and `right`). The left pointer needs to be incremented and right pointer needs to decremented for each iteration.
+
+4. Invoke reversal operation for entire array of elements(i.e, from the beggining to end of an array).
+
+5. Invoke reversal operation for first `n` number of elements(i.e, from the beggining to n-1).
+
+6. Invoke reversal operation for remaining number of elements(i.e, from `n-1` to end of an array).
+
+7. Return in-place rotated array as output.
+
+**Time and Space complexity:**
+
+This algorithm has a time complexity of `O(n)`, where `n` is the number of elements. This is because we are performing three reversal operations on subarrays and each reversal operation takes O(n). So the overall time complexity is O(n). 
+
+Here, we don't use any additional datastructure due to in-place rotation. Hence, the space complexity will be O(1).
+