LeetCode刷题之189. 轮转数组

题目:

给定一个整数数组 nums,将数组中的元素向右轮转 k 个位置,其中 k 是非负数。

示例:

示例 1:

输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]

示例 2:

输入:nums = [-1,-100,3,99], k = 2
输出:[3,99,-1,-100]
解释:
向右轮转 1 步: [99,-1,-100,3]
向右轮转 2 步: [3,99,-1,-100]


提示:

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


进阶:

尽可能想出更多的解决方案,至少有 三种 不同的方法可以解决这个问题。
你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗?
方法一:使用额外的数组

我们可以使用额外的数组来将每个元素放至正确的位置。用 n表示数组的长度,我们遍历原数组,将原数组下标为 i的元素放至新数组下标为(i+k) mod n 的位置,最后将新数组拷贝至原数组即可。

class Solution {
public:
    void rotate(vector& nums, int k) {
        int n = nums.size();
        vector newArr(n); //定义了n个整型元素的向量(尖括号中为元素类型名,它可以是任何合法的数据类型),但没有给出初值,其值是不确定的。
        for (int i = 0; i < n; i ++) {
            newArr[(i + k) % n] =  nums[i];
        }
        nums.assign(newArr.begin(), newArr.end());
    }
};

复杂度分析

  • 时间复杂度:O(n),其中 n 为数组的长度。

  • 空间复杂度:O(n)。

方法二:数组翻转

该方法基于如下的事实:当我们将数组的元素向右移动 k 次后,尾部k mod n个元素会移动至数组头部,其余元素向后移动k mod n个位置。

该方法为数组的翻转:我们可以先将所有元素翻转,这样尾部的 k mod n 个元素就被移至数组头部,然后我们再翻转 [0,k mod n−1] 区间的元素和 [k mod n,n−1] 区间的元素即能得到最后的答案。

我们以 n=7,k=3 为例进行如下展示:

操作

结果

原始数组

1 2 3 4 5 6 7

翻转所有元素

7 6 5 4 3 2 1

翻转[0, k mod n - 1]区间的元素

5 6 7 4 3 2 1

翻转[k mod n, n - 1]区间的元素

5 6 7 1 2 3 4

一个天才的可视化解题过程(如下):

nums = "----->-->"; k =3
result = "-->----->";

reverse"----->-->" we can get"<--<-----"
reverse"<--" we can get"--><-----"
reverse"<-----" we can get"-->----->"
this visualization help me figure it out :)

复杂度分析

时间复杂度:O(n),其中 n 为数组的长度。每个元素被翻转两次,一共 n 个元素,因此总时间复杂度为 O(2n)=O(n)。

空间复杂度:O(1)。

class Solution {
public:
    void reverse(vector& nums, int start, int end) {
        while (start < end) {
            swap(nums[start], nums[end]);
            start += 1;
            end -= 1;
        }
    }
    void rotate(vector& nums, int k) {
        k %= nums.size();
        reverse(nums, 0, nums.size() - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, nums.size() - 1);
    }
};
class Solution {
    public void rotate(int[] nums, int k) {
        k %= nums.length;
        reverse(nums, 0, nums.length - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, nums.length - 1);
    }

    public void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int temp = nums[start];
            nums[start] = nums[end];
            nums[end] = temp;
            start += 1;
            end -= 1;
        }
    }
}

Tips:

(1)assign()函数用法:
assign()函数主要是将一个容器中元素全部复制到另一个容器中。

(1)void assign(const_iterator first,const_iterator last)

将区间[first,last)的元素赋值到当前的vector容器中

(2)void assign(size_type n,const T& x = T());

赋n个值为x的元素到vector容器中,这个容器会清除掉vector容器中以前的内容。
(2)vector的用法:

vector是向量类型,它可以容纳许多类型的数据,如若干个整数,所以称其为容器。vector 是C++ STL的一个重要成员,使用它时需要包含头文件:

#include;

一、vector 的初始化:可以有五种方式,举例说明如下:

(1) vector a(10); //定义了10个整型元素的向量(尖括号中为元素类型名,它可以是任何合法的数据类型),但没有给出初值,其值是不确定的。

(2)vector a(10,1); //定义了10个整型元素的向量,且给出每个元素的初值为1

(3)vector a(b); //用b向量来创建a向量,整体复制性赋值

(4)vector a(b.begin(),b.begin+3); //定义了a值为b中第0个到第2个(共3个)元素

(5)int b[7]={1,2,3,4,5,9,8};

vector a(b,b+7); //从数组中获得初值

二、vector对象的几个重要操作,举例说明如下:

(1)a.assign(b.begin(), b.begin()+3); //b为向量,将b的0~2个元素构成的向量赋给a

(2)a.assign(4,2); //是a只含4个元素,且每个元素为2

(3)a.back(); //返回a的最后一个元素

(4)a.front(); //返回a的第一个元素

(5)a[i]; //返回a的第i个元素,当且仅当a[i]存在2013-12-07

(6)a.clear(); //清空a中的元素

(7)a.empty(); //判断a是否为空,空则返回ture,不空则返回false

(8)a.pop_back(); //删除a向量的最后一个元素

(9)a.erase(a.begin()+1,a.begin()+3); //删除a中第1个(从第0个算起)到第2个元素,也就是说删除的元素从a.begin()+1算起(包括它)一直到a.begin()+ 3(不包括它)

(10)a.push_back(5); //在a的最后一个向量后插入一个元素,其值为5

(11)a.insert(a.begin()+1,5); //在a的第1个元素(从第0个算起)的位置插入数值5,如a为1,2,3,4,插入元素后为1,5,2,3,4

(12)a.insert(a.begin()+1,3,5); //在a的第1个元素(从第0个算起)的位置插入3个数,其值都为5

(13)a.insert(a.begin()+1,b+3,b+6); //b为数组,在a的第1个元素(从第0个算起)的位置插入b的第3个元素到第5个元素(不包括b+6),如b为1,2,3,4,5,9,8 ,插入元素后为1,4,5,9,2,3,4,5,9,8

(14)a.size(); //返回a中元素的个数;

(15)a.capacity(); //返回a在内存中总共可以容纳的元素个数

(16)a.resize(10); //将a的现有元素个数调至10个,多则删,少则补,其值随机

(17)a.resize(10,2); //将a的现有元素个数调至10个,多则删,少则补,其值为2

(18)a.reserve(100); //将a的容量(capacity)扩充至100,也就是说现在测试a.capacity();的时候返回值是100.这种操作只有在需要给a添加大量数据的时候才 显得有意义,因为这将避免内存多次容量扩充操作(当a的容量不足时电脑会自动扩容,当然这必然降低性能)

(19)a.swap(b); //b为向量,将a中的元素和b中的元素进行整体性交换

(20)a==b; //b为向量,向量的比较操作还有!=,>=,<=,>,<

三、几种重要的算法,使用时需要包含头文件:

#include

(1)sort(a.begin(),a.end()); //对a中的从a.begin()(包括它)到a.end()(不包括它)的元素进行从小到大排列

(2)reverse(a.begin(),a.end()); //对a中的从a.begin()(包括它)到a.end()(不包括它)的元素倒置,但不排列,如a中元素为1,3,2,4,倒置后为4,2,3,1

(3)copy(a.begin(),a.end(),b.begin()+1); //把a中的从a.begin()(包括它)到a.end()(不包括它)的元素复制到b中,从b.begin()+1的位置(包括它)开 始复制,覆盖掉原有元素

(4)find(a.begin(),a.end(),10); //在a中的从a.begin()(包括它)到a.end()(不包括它)的元素中查找10,若存在返回其在向量中的位置

你可能感兴趣的:(LeetCode,c++,开发语言,leetcode,学习,算法)