Description（189.轮转数组）

给你一个数组，将数组中的元素向右轮转 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 <= 10^5
-2^31 <= nums[i] <= 2^31 - 1
0 <= k <= 10^5

进阶：

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

Solution

第一种解法：

使用额外的数组来将每个元素转换到正确的位置。用n表示数组的长度，遍历原数组，将原数组下标为最i的元素换到（i+k）%n的位置，最后将新数组放到原数组即可。

var rotate = function(nums, k) {
    const n = nums.length;
    const newArr = new Array(n);
    for (let i = 0; i < n; ++i) {
        newArr[(i + k) % n] = nums[i];
    }
    for (let i = 0; i < n; ++i) {
        nums[i] = newArr[i];
    }
}

第二种解法：

对数组进行翻转，首先对整个数组进行翻转，然后将0～k mod n-1区间的元素和k mod n～n-1的元素再次翻转，就可以得到最后的答案。

const reverse = (nums, start, end) => {
    while (start < end) {
        const temp = nums[start];
        nums[start] = nums[end];
        nums[end] = temp;
        start += 1;
        end -= 1;
    }
}

var rotate = function(nums, k) {
    k %= nums.length;
    reverse(nums, 0, nums.length - 1);
    reverse(nums, 0, k - 1);
    reverse(nums, k, nums.length - 1);
};

Description（283. 移动零）

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

示例:

输入: [0,1,0,3,12]
输出: [1,3,12,0,0]

说明:

必须在原数组上操作，不能拷贝额外的数组。
尽量减少操作次数。

Solution

解题思路很简单，可以说是将数组中的0直接删除，将0后面的元素都往前提一个，然后pop数组最后一个元素，再把0补进去就可以，要注意是循环的顺序是要从后往前，而不是从前往后，因为是把元素往前提一个，不适合从前往后。

var moveZeroes = function(nums) {
    let left = 0, right = nums.length -1;
    const total = nums.length -1;
    let anoth = 0;
    while(left <= right){
        if(nums[right] == 0){
            for(i = right; i < total; ++i ){
                anoth = nums[i+1];
                nums[i] = anoth;
            }
            nums.pop(nums[total]);
            nums.push(0);
        }
        -- right;
    }
};

Description（167. 两数之和II - 输入有序数组）

给定一个已按照非递减顺序排列的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。

函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标从 1 开始计数，所以答案数组应当满足 1 <= answer[0] < answer[1] <= numbers.length 。

你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。

示例 1：

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。

示例 2：

输入：numbers = [2,3,4], target = 6
输出：[1,3]

示例 3：

输入：numbers = [-1,0], target = -1
输出：[1,2]

提示：

2 <= numbers.length <= 3 * 104
-1000 <= numbers[i] <= 1000
numbers 按非递减顺序排列
-1000 <= target <= 1000
仅存在一个有效答案

Solution

因为是非减序数组，所以可以通过两条指针数据进行判断，一条从头部开始，一条从尾部开始，如果符合需要的值，就将其下表+1后push到新数组，如果不是，就继续通过指针进行遍历，知道找到合适的组合。

var twoSum = function(numbers, target) {
    const total = numbers.length - 1;
    let left = 0,right = total,need = 0;
    let result = [];
    while(left < right){
        need = target - numbers[right];
        if(need == numbers[left]){
           result.push(++left);               
           result.push(++right);
           break;
        }else if(need > numbers[left]){
            ++left;
        }else{
            --right;
        }
    }
    return result;
};