leetcode：189. 轮转数、34. 在排序数组中查找元素的第一个和最后一个位置、724. 寻找数组的中心下标（JavaScript）

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]

思路

注意：本题有个小坑，题目输入中，如果 k 大于 nums.length 了应该怎么办？

其实就是右移 k % nums.length 次，即：15 % 7 = 1

本题最容易想到的就是双重循环，暴力解法，首先循环 k 次，每次将数组元素向右轮转一个位置。

var rotate = function(nums, k) {
    k = k % nums.length;
    //遍历k次，操作元素向右轮转
    for (let j = 1; j <= k; j++) {
        let tem = nums[nums.length - 1];
        // 遍历数组元素，将数组元素向右轮转一个位置
        for (let i = nums.length - 1; i >= 1 ; i--) {
            nums[i] = nums[i - 1];
        }
        nums[0] = tem;
    }
};

不得行不得行，事件复杂度太高了，怎么给优化一下呢？观察轮转前和轮转后的数组，轮转后的数组就是将原数组的最后 k 个元素以原顺序移到了数组的前边。完成这个动作需要三步

1. 拿到后 k 个元素。
2. 将原数组前 nums.length - k 个元素向后移动 k 个位置。
3. 将后 k 个元素按顺序放入到数组中。

var rotate = function(nums, k) {
    k = k % nums.length;
    const tem = [];
    // 第一步
    for (let j = nums.length - k; j < nums.length; j++) {
        tem.push(nums[j])
    }
    // 第二步
    for (let i = nums.length - 1; i >= k; i--) {
        nums[i] = nums[i - k];
    }
    // 第三步
    for (let i = 0; i < k ; i++) {
        nums[i] = tem[i];
    }
}

再仔细想一想，这一题还可以怎么做呢？其实可以发现这一题还可以使用翻转数组的方法，以例子 [1,2,3,4,5,6,7] 说明：

1. 翻转整个数组得到 [7,6,5,4,3,2,1]
2. 翻转前 k 个元素得到 [5,6,7,4,3,2,1]
3. 翻转后 nums.length - k 个元素的到 [5,6,7,1,2,3,4]

是不是很巧妙，其实很多数组轮转的题目都可以使用这种解法

 var rotate = function(nums, k) {
    k = k % nums.length;
    // 定义翻转函数
    function reverses(nums, i, j) {
        while (i < j) {
            [nums[i], nums[j]] = [nums[j], nums[i]]
            i++;
            j--;
        }
    }
     //第一步
    nums.reverse();
      //第二步
    reverses(nums, 0, k - 1);
      //第三步
    reverses(nums, k, nums.length - 1);
    return nums;
};

34. 在排序数组中查找元素的第一个和最后一个位置

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

进阶：

• 你可以设计并实现时间复杂度为 O(log n) 的算法解决此问题吗？

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：

输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：

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

思路

本题还是比较简单的一题，因为题目说了，数组元素按升序排列，那么相等的元素一定在一起，所以可以先从前边找 target 位置，再从后边找。这里借助 js 的 API 。

var searchRange = function(nums, target) {
    const l = nums.indexOf(target);
    const r = nums.lastIndexOf(target);
    return [l,r];
};

也可以从前边开始先找到 target 出现的位置，再继续遍历找 target 结束的位置

var searchRange = function(nums, target) {
    let l = 0, r = l;
    // 找target第一次出现的位置
    while(l < nums.length && nums[l] !== target){
        l++;
    }
    r = l;
    // 从第一次出现的位置找 target 最后一次出现的位置
    while (r < nums.length && nums[r] === target) {
        r++;
    }
    return (l === r && l === nums.length) ? [-1,-1] : [l,r - 1];
};

724. 寻找数组的中心下标

给你一个整数数组 nums ，请计算数组的 中心下标 。

数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。

如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下标位于数组最右端同样适用。

如果数组有多个中心下标，应该返回 最靠近左边 的那一个。如果数组不存在中心下标，返回 -1 。

示例 1：

输入：nums = [1, 7, 3, 6, 5, 6]
输出：3
解释：
中心下标是 3 。
左侧数之和 sum = nums[0] + nums[1] + nums[2] = 1 + 7 + 3 = 11 ，
右侧数之和 sum = nums[4] + nums[5] = 5 + 6 = 11 ，二者相等。

示例 2：

输入：nums = [1, 2, 3]
输出：-1
解释：
数组中不存在满足此条件的中心下标。

示例 3：

输入：nums = [2, 1, -1]
输出：0
解释：
中心下标是 0 。
左侧数之和 sum = 0 ，（下标 0 左侧不存在元素），
右侧数之和 sum = nums[1] + nums[2] = 1 + -1 = 0 。

思路

这道题目还是比较简单的

1. 遍历一遍求出总和rsum，并将其作为右半和值。
2. 遍历第二遍求中心索引左半和lsum
   • 右半和要减去当前的元素， 因为前元素不算是右半的值了 rsum - nums[i]。
   • 判断lsum和rsum是否相同。
   • 如不相同，那么左半和要加上当前元素，因为 i + 1 后当前元素就算是左半的元素了。

var pivotIndex = function(nums) {
    let rsum = 0, lsum = 0, index = -1;
    // 求总和并做为右半和
    for (let i = 0; i < nums.length; i++) {
        rsum += nums[i];
    }
    // 遍历求中心索引
    for ( index = 0; index < nums.length; index++) {
        rsum -= nums[index];
        if (lsum === rsum) {
            return index;
        } else {
            lsum += nums[index];
        }
    }
    return -1;
};