自学在力扣学习的算法题，初学者水平数组的相关题目,所有相关题目出自力扣

题目一：

输入：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 ，二者相等。

/**
 * @param {number[]} nums
 * @return {number}
 */
//  var一个函数自带参数nums
var pivotIndex = function (nums) {
    // let声明两个变量
    let sumL = 0,
        sumR = 0;
    // 求数组总和每一项相加累计
    for (let item of nums) {
        sumR += item
    }
    // for循环搞出这个数组的所有下标
    for (let i = 0; i < nums.length; i++) {
        // 如果 sumL 与 sumR 减去当前值之后的结果相等，就返回该下标
        if (sumL === (sumR -= nums[i])) return i
        // 否则 sumL 加上当前值，指针右移
        sumL += nums[i]
    }
    // 最后返回出来的结果减一最终的中心数
    return -1
};

题目二：

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
//  创建一个函数
// 注入nums和target两个参数
var searchInsert = function(nums, target) {
    // 生命变量开始的下标，结束的一个下标
    let start = 0, end = nums.length - 1
// 通过while循环开始下标小于等于结束下标执行下面的代码
    while(start <= end){
        // 声明一个变量mid的值等于结束下标减去开始下表大于1就加上开始下标
        let mid = ((end - start) >> 1) + start
        // 判断target这个参数值小于等于nums数组mid下标下的值
        if(target <= nums[mid] ) {
            // 结束下标就等于mid变量减一
            end = mid - 1
            // 否则的话
        } else{
            start = mid + 1
            // 开始下标就等于mid变量加一
        }
    }
     //返回开始下标
    return start
};

 题目三:

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

示例 1：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
示例 2：

输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。

/**
 * @param {number[][]} intervals
 * @return {number[][]}
 */
var merge = function (intervals) {
    // 根据每个子区间的起点升序排序
    intervals.sort((a, b) =>
    // intervals[0]进行的升序排序
        a[0] - b[0]
    )
    // 设置memo的缓存存下intervals[0]数值
    let memo = [intervals[0]]
    // 通过for拿到i下标
    for (let i = 1; i < intervals.length; i++) {
        // 如果当前区间被缓存区间包含，则跳过
        // 其实就是intervals[i][1]i下标下的第一个数值小于等于缓存数值memo它的长度减一下标下的第一个值那么跳过
        if (intervals[i][1] <= memo[memo.length - 1][1]) continue
        // continue持续

        // 如果当前区间可以与缓存区间合并，则将其合并
        // 其实就是intervals[i][0]i下标下的第零个数值小于等于缓存数值memo它的长度减一下标下的第一个值
        if (intervals[i][0] <= memo[memo.length - 1][1]) {
            // 那么就让memo它的长度减一下标下的第一个值等于intervals[i][1]i下标下的第一个数值
            memo[memo.length - 1][1] = intervals[i][1]
        } 
        
        // 如果既不包含也不能合并，则作为一个独立区间放入缓存
        else memo.push(intervals[i])
        
    }
    // 最后输出它们的合并区间
    return memo
};

 明天继续学习二维数组!!!