Welcome to Subscribe On Youtube

189. Rotate Array

Description

Given an integer array nums, rotate the array to the right by k steps, where k is non-negative.

 

Example 1:

Input: nums = [1,2,3,4,5,6,7], k = 3
Output: [5,6,7,1,2,3,4]
Explanation:
rotate 1 steps to the right: [7,1,2,3,4,5,6]
rotate 2 steps to the right: [6,7,1,2,3,4,5]
rotate 3 steps to the right: [5,6,7,1,2,3,4]

Example 2:

Input: nums = [-1,-100,3,99], k = 2
Output: [3,99,-1,-100]
Explanation: 
rotate 1 steps to the right: [99,-1,-100,3]
rotate 2 steps to the right: [3,99,-1,-100]

 

Constraints:

• 1 <= nums.length <= 105
• -231 <= nums[i] <= 231 - 1
• 0 <= k <= 105

 

Follow up:

• Try to come up with as many solutions as you can. There are at least three different ways to solve this problem.
• Could you do it in-place with O(1) extra space?

Solutions

Solution 1: Reverse three times

We can assume the length of the array is $n$ and calculate the actual number of steps needed by taking the module of $k$ and $n$, which is $kmodn$.

Next, let us reverse three times to get the final result:

1. Reverse the entire array.
2. Reverse the first $k$ elements.
3. Reverse the last $n-k$ elements.

For example, for the array $[1,2,3,4,5,6,7]$, $k=3$, $n=7$, $kmodn=3$.

1. In the first reverse, reverse the entire array. We get $[7,6,5,4,3,2,1]$.
2. In the second reverse, reverse the first $k$ elements. We get $[5,6,7,4,3,2,1]$.
3. In the third reverse, reverse the last $n-k$ elements. We get $[5,6,7,1,2,3,4]$, which is the final result.

The time complexity is $O(n)$, where $n$ is the length of the array. The space complexity is $O(1)$.

• Java
• C++
• Python
• Go
• TypeScript
• Javascript
• C#
• RenderScript

• class Solution {
      private int[] nums;
  
      public void rotate(int[] nums, int k) {
          this.nums = nums;
          int n = nums.length;
          k %= n;
          reverse(0, n - 1);
          reverse(0, k - 1);
          reverse(k, n - 1);
      }
  
      private void reverse(int i, int j) {
          for (; i < j; ++i, --j) {
              int t = nums[i];
              nums[i] = nums[j];
              nums[j] = t;
          }
      }
  }
  

• class Solution {
  public:
      void rotate(vector<int>& nums, int k) {
          int n = nums.size();
          k %= n;
          reverse(nums.begin(), nums.end());
          reverse(nums.begin(), nums.begin() + k);
          reverse(nums.begin() + k, nums.end());
      }
  };
  

• class Solution:
      def rotate(self, nums: List[int], k: int) -> None:
          k %= len(nums)
          nums[:] = nums[-k:] + nums[:-k]
  
  ############
  
  class Solution:
      def rotate(self, nums: List[int], k: int) -> None:
          """
          Do not return anything, modify nums in-place instead.
          """
          n = len(nums)
          k %= n
          if n < 2 or k == 0:
              return
          nums[:] = nums[::-1]
          nums[:k] = nums[:k][::-1]
          nums[k:] = nums[k:][::-1]
  
  ############
  
  class Solution(object):
    def rotate(self, nums, k):
      """
      :type nums: List[int]
      :type k: int
      :rtype: void Do not return anything, modify nums in-place instead.
      """
      if len(nums) == 0 or k == 0:
        return
  
      def reverse(start, end, s):
        while start < end:
          s[start], s[end] = s[end], s[start]
          start += 1
          end -= 1
  
      n = len(nums) - 1
      k = k % len(nums)
      reverse(0, n - k, nums)
      reverse(n - k + 1, n, nums)
      reverse(0, n, nums)
  
  
  

• func rotate(nums []int, k int) {
  	n := len(nums)
  	k %= n
  	reverse := func(i, j int) {
  		for ; i < j; i, j = i+1, j-1 {
  			nums[i], nums[j] = nums[j], nums[i]
  		}
  	}
  	reverse(0, n-1)
  	reverse(0, k-1)
  	reverse(k, n-1)
  }
  

• /**
   Do not return anything, modify nums in-place instead.
   */
  function rotate(nums: number[], k: number): void {
      const n: number = nums.length;
      k %= n;
      const reverse = (i: number, j: number): void => {
          for (; i < j; ++i, --j) {
              const t: number = nums[i];
              nums[i] = nums[j];
              nums[j] = t;
          }
      };
      reverse(0, n - 1);
      reverse(0, k - 1);
      reverse(k, n - 1);
  }
  
  

• /**
   * @param {number[]} nums
   * @param {number} k
   * @return {void} Do not return anything, modify nums in-place instead.
   */
  var rotate = function (nums, k) {
      const n = nums.length;
      k %= n;
      const reverse = (i, j) => {
          for (; i < j; ++i, --j) {
              [nums[i], nums[j]] = [nums[j], nums[i]];
          }
      };
      reverse(0, n - 1);
      reverse(0, k - 1);
      reverse(k, n - 1);
  };
  
  

• public class Solution {
      private int[] nums;
  
      public void Rotate(int[] nums, int k) {
          this.nums = nums;
          int n = nums.Length;
          k %= n;
          reverse(0, n - 1);
          reverse(0, k - 1);
          reverse(k, n - 1);
      }
  
      private void reverse(int i, int j) {
          for (; i < j; ++i, --j) {
              int t = nums[i];
              nums[i] = nums[j];
              nums[j] = t;
          }
      }
  }
  

• impl Solution {
      pub fn rotate(nums: &mut Vec<i32>, k: i32) {
          let n = nums.len();
          let k = (k as usize) % n;
          nums.reverse();
          nums[..k].reverse();
          nums[k..].reverse();
      }
  }
  
  

All Problems

All Solutions